Software architecture system and method for discovering components within an appliance using fuctionality identifiers

ABSTRACT

A network comprising a plurality of nodes, and each of the nodes has at least one identifier from pre-determined group of identifiers, with each identifier identifying at least one functionality applicable such node. A method of identifying the nodes comprises at least one node sending over the network a message configured to ask for the presence of at least one identifier from the pre-determined group of identifiers. At least one other node sends a feedback message affirming the existence of the at least one identifier on the at least one other node.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of International Application No.PCT/US06/22420, filed Jun. 8, 2006, which claims the benefit of U.S.Patent Application No. 60/595,148, filed Jun. 9, 2005, whose disclosureis incorporated by reference.

BACKGROUND OF THE INVENTION

1. Field of the Invention

The invention relates to a software architecture system and method fordiscovering components within an appliance using functionalityidentifiers.

2. Description of the Related Art

Household appliances are typically comprised of one or more componentswhich cause the electromechanical, electrothermal, and electrochemicaloperations of the appliance. For example, an oven may include anappliance management component, having a printed circuit board (PCB)with memory thereon, as well as a user interface component, such as acontrol panel or keypad for a user to issue commands to the ovenappliance. The basic appliance models typically are difficult to design,develop, test, diagnose, control, and debug due to the diversity ofcomponentry and the associated diversity of implementation choices. Thisdiversity is an impediment to creating interoperable, reusable, valueadded componentry.

It has become known in recent years to interlink the components of anappliance by an internal communications network capable of sending andreceiving control messages for controlling the interaction between theinternal components of an appliance, as opposed to the use of aplurality of discrete circuits, with each discrete circuit responsiblefor an individual communication between related components andimplemented by hard-wiring ribbon cables or other connectors orharnesses between the components. This internal network affords somedegree of universality in connecting the components internal to theappliance, however, each component typically needs to be enabled withsoftware within its microprocessor and the adjacent hardware circuitryto achieve network participation. One example of this internal networkused within a household appliance is the WIDE network protocol, createdby Whirlpool, Inc., the assignee of this document.

SUMMARY OF THE INVENTION

A method according to one embodiment of the invention of identifyingnodes in a network having a plurality of nodes, each of the nodes havingat least one identifier from pre-determined group of identifiers, witheach identifier identifying at least one functionality applicable suchnode, comprising at least one node sending over the network a messageconfigured to ask for the presence of at least one identifier from thepre-determined group of identifiers; and at least one other node sendinga feedback message affirming the existence of the at least oneidentifier on the at least one other node.

A method according to another embodiment of the invention of identifyingnodes in an appliance having a plurality of interconnected nodes forminga communications network, at least some of the nodes having acorresponding component, wherein the components are operably coupled bythe communications network to cooperatively perform a useful cycle ofoperation, each of the nodes having at least one identifier frompre-determined group of identifiers, with each identifier identifying atleast one functionality applicable to the corresponding component,comprises at least one node sending over the network a commandconfigured to ask for the presence of at least one identifier from thepre-determined group of identifiers; and at least one other node sendinga feedback message affirming the existence of the at least oneidentifier on the at least one other node.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a schematic illustration showing a household appliance havingan internal communication network interconnecting a plurality ofcomponents, wherein each component has a software architecture embeddedtherein according to the invention, the household appliance also havingan external communications connection showing various network interfacecards (NICs) establishing communication with various embodiments ofexternal clients.

FIG. 2 is a schematic illustration of the internal communicationsnetwork of FIG. 1 showing the software architecture (SA) according tothe invention interposed between the internal communications network andvarious software components of physical components internal to thehousehold appliance.

FIG. 3 is a schematic illustration of the internal communicationsnetwork of FIG. 1 showing the internal communications networkfunctioning as a physical support for the SA residing on two components(a Lower Layer, which represents the network physical layer and is notdirectly associated with the SA, and a Higher Layer, which representssupport for packet structure and is directly an element of the SA). withthe SA used by the components to communicate through informationexchange and to interact with other software operating layers residingon the components to achieve the results in accordance with theinformation exchanged between components according to the invention.

FIG. 4 is a schematic illustration of a packet structure for theinternal communications network of the household appliance shown in FIG.1 having a payload portion comprising an application packet structurefor the software architecture according to the invention.

FIG. 5 is a schematic illustration of communication between a SAresiding on a controller, controller SA, of the appliance and an SAresiding on a component to create a client relationship, client SA,relative to the SA on the controller where various variables and eventsare transmitted between the controller SA and the client SA.

FIG. 5A is a schematic illustration similar to FIG. 5 and illustratingthe client as an external client at a remote location in the form of acustomer call support center to illustrate an exchange of data used toperform remote diagnosis of the appliance.

FIG. 6 is a schematic illustration similar to that shown in FIG. 5illustrating a discovery technique contained in the softwarearchitecture of FIG. 1 according to the invention.

FIG. 7 is a schematic illustration of various exemplary states of asoftware operating environment typically operating within the ControlLogic element as shown in FIG. 3 within a component of a householdappliance, which is illustrated as a washer.

FIG. 8 is a schematic illustration showing the response of thecontroller SA to various information exchanges in the form of commandsissued and received by other SA installations to validate or rejectthose commands based upon the state of the household appliance as wellas the internal state of the controller SA.

FIG. 9 is a schematic illustrating the usage of binding to link multipledata exchanges to form a single command and/or update between a clientSA and the controller SA.

FIG. 10 is a schematic illustration showing the SA in relation to theoverall software environment of a component, where the softwareenvironment comprises various software operating layers, with thesoftware architecture comprising a command handler, an update handlerand an internal communications network layer interface forinterconnecting the SA to the internal communications network of thehousehold appliance.

FIG. 11 is a schematic illustration showing the invocation of thecontroller SA by the supervisory scheduler (MAIN) residing on the maincontroller, which also invokes a subroutine call to expose functions ofclient SA's on the network.

FIG. 12 is a schematic illustration showing the interface between theinternal appliance application logic and the software architecture shownin FIG. 11 including a callback section.

FIG. 13 is a schematic illustration of the example implementation of thesoftware architecture shown in FIG. 11 including an applianceinitialization section.

FIG. 14 is a schematic illustration of a pair of software operatingenvironments, each corresponding to a different component with its ownSA, and connected by the internal communications network.

FIG. 15 is a schematic illustration of a persistence node exposed toother components within the Parrot Appliance via network 14 andsupporting packet structure 28 of the software architecture 10 of FIG. 1according to the invention.

FIG. 16 is a schematic illustration of a prior art method by whichexternal commands are translated into key presses for testing householdappliance functionality.

FIG. 17 is a schematic illustration of the interaction of user-initiatedkey presses and externally-fed software commands are passed as argumentsto the SA for issuing commands to a household appliance to, e.g., testhousehold appliance functionality and/or change the state of thehousehold appliance machine.

FIG. 18 is a schematic illustration showing mounting of a NIC in arecess formed in a rear side of the appliance.

FIG. 19 is a schematic illustration showing mounting of the NIC to afront side of the appliance and a wiring conduit extending from themounting location of the network interface card to the rear side of theappliance.

FIG. 20 is a schematic illustration of the appliance comprising a safetybarrier that allows communication from an RF PCB located in theappliance and prevents human contact with excessive heat and/orelectricity.

FIG. 21 is a schematic illustration illustrating the use of a servicemodule that obtains diagnostic data from the appliance and uploads thediagnostic data via a personal computer over an external network.

FIG. 21A is a schematic illustration of architecture for the servicemodule of FIG. 21.

FIG. 22 is a schematic illustration similar to FIG. 21 with the servicemodule uploading the diagnostic data via a telephone line.

FIG. 22A is a schematic illustration of architecture for the servicemodule of FIG. 22.

FIG. 23 is a schematic illustration of the appliance in the form of arefrigerator equipped with an exemplary accessory module in the form ofa weather station module forming a component with a client SA enablingthe weather station module to become operational without manualconfiguration.

FIG. 24 is a schematic illustration of a fragmentation packet structurefor the internal communications network of the household appliance shownin FIG. 1 having protocol for handling fragmented packet integrity,which replaces the protocol illustrated in FIG. 4 when a message must bebroken into multiple messages.

FIG. 25 illustrates a sequence of packets representing a series offragmented messages transmitted in the form shown in FIG. 2, which areby the receiving SA and reformed into the original cohesive data setscreated by the sender of the packets.

FIG. 26A is a schematic illustration of the location of variable mapinformation at a central location, such as the main controller PC board,which is then communicated to the boards of the other components.

FIG. 26B is a schematic illustration of the location of variable mapinformation on the controller of the component, which is collected fromthe other components on the network.

FIG. 27 is a UML Sequence Diagram showing a messaging scenario where aduplicate event request is assigned a variable address to permit bothrequests to reside in the network.

FIG. 28 is a UML sequence diagram of a standard format illustrating thedisabling and re-enabling of the realization event requests.

FIG. 29 is a UML sequence diagram of an acknowledged event within theSA, where the controller SA waits a pre-determined time for anacknowledgement message from the client SA until processing the nextevent.

FIG. 30 is a UML state diagram of a standard format illustrating thesecurity modes and firewall provided by this invention.

FIG. 31 is a UML sequence diagram illustrating the methods ofinteraction between a client which must negotiate with the firewall ofFIG. 30 before application messaging can be fully processed.

FIG. 32 is a UML class diagram illustrating the standard publicinterfaces which the SA is able to implement.

FIG. 33 is a UML class diagram illustrating the preferred implementationof the SA.

FIG. 34 shows the preferred organization of source code files of the SA.

FIG. 35 shows a collection of inter-related UML state diagramsillustrating 3 primary states (COMM_IDLE, COMM_EXPECTING ACK, andCOMM_PENDING), each of which possibly having a plurality of sub-states.

FIG. 36 shows a collection of inter-related UML state diagramsillustrating 4 primary states (READY, TRANSMIT SNAPSHOT,UPDATES_BLOCKED, and PROCESS_DAQ_EVENTS).

FIG. 37 shows a collection of inter-related UML state diagramsillustrating 2 primary states (MSG_READY and MSG_PROCESS).

FIG. 38 is a UML sequence diagram illustrating the execution of anordered collection of internal messages between components for thepurpose of producing a network message on the internal network from theSA.

FIG. 39 is a UML sequence diagram illustrating the execution of anordered collection of messages of the classes in FIG. 33 of the softwareoperating environment.

FIG. 40 is a UML sequence diagram showing an ordered collection ofmessages of the classes in FIG. 33 of the software operatingenvironment.

FIG. 41 is a UML sequence diagram illustrating the messaging required toprocess incoming messages from the WIDE bus 14 from clients 22/16 whichdo not require a response containing meaningful data other than aresponse transmitting the success or the reason for failure of theincoming message (the ACK or NAK of API ID=1, Op Code=1).

FIG. 42 is a UML sequence diagram illustrating the messaging required toprocess incoming messages from the WIDE bus 14 from clients 22/16 whichrequire a plurality of response messages containing meaningful data inaddition to a response which transmits the success or the reason forfailure of the incoming message (the ACK or NAK of API ID=1, Op Code=1).

FIG. 43 is a UML sequence diagram illustrating the messaging required toprocess incoming messages from the WIDE bus 14 from clients 22/16 whichrequire a single response messages containing meaningful data inaddition to a response which transmits the success or the reason forfailure of the incoming message (the ACK or NAK of API ID=1, Op Code=1).

FIG. 44 schematically illustrates a taxonomy control using a taxonomydataset to control the operation of one or more components within theappliance without direct knowledge of the functions for the component.

FIG. 45 schematically illustrates a user interface populated by ataxonomy dataset comprising a hierarchy of options and data inputs thatwill lead the user to selecting options and data inputs to generate awell formed command.

FIG. 46 schematically illustrates the associated data inputs availablefor a top level option.

FIG. 47 schematically illustrates the associated data inputs availablefor a sub-level option selection with associated data inputs.

DESCRIPTION OF EMBODIMENTS OF THE INVENTION

A brief overview of the invention should be helpful before examining themultiple aspects of the invention. The invention relates to a softwarearchitecture (“SA”) that is implemented on and communicates over aninternal communications network on an appliance, which connects thevarious physical components of the appliance.

Some of the physical components have a corresponding controller (maincontroller, motor controller, user interface, etc.), which may be asimple microprocessor mounted on a printed circuit board. Othercomponents have no controller. Typically the components that havecontrollers (and if there are more than one are typically also networkenabled) cooperate through network messaging or other forms of datatransmission to directly or indirectly, through other components,control the operation of all of the components and their contained orattached devices to implement an operation or cycle for the appliance.

The SA can, but does not have to, reside on each of the components witha controller. Those components with the SA or a variant of the SAcompliant with the SA (compliance determined by the ability to send,receive, and process packets) form a node on the network that cancommunicate with the other nodes.

The SA performs multiple functions: identifying each of the componentscorresponding to a node to the network; identifying the capabilities orfunctions of the identified components to the network; identifying thestatus of the components to the network; providing well defined commandinterfaces for each component; providing communication between internaland external software components that are not part of the SA; andproviding communication between components non-SA software components ondifferent physical components. In this way, the SA functions to informall of the nodes on the network of the presence, capabilities, andstatus of the other nodes.

The SA comprises multiple modules, each of which has differentfunctionality. Various combinations of the modules or all of the modulescan reside on each of the components. One module having the basic orcore functionality for the invention resides on all of the components.In one anticipated configuration, all of the modules reside at least onthe main controller, which establishes the main controller to functionas a primary or controller SA, with the other nodes functioning in aclient relationship to the controller SA. In such a configuration, allof the nodes would communicate through the Controller SA.

The SA is sufficiently robust that it can permit configurations withouta Controller SA or with multiple Controller SA. Regardless of theconfiguration, any component with a residing SA can function as a clientwith respect to the other components.

The internal communications can be connected to one or more externalcomponents directly or through an external network. The externalcomponents would also have one, some, or all of the SA modules inresident.

Beginning with FIG. 1, the specifics of the invention will now bedescribed. FIG. 1 is a schematic illustrating one environment of asoftware architecture 10, (embodying the systems and methods describedherein and those which would be apparent to one skilled in the art) inthe form of a household appliance 12 having an internal communicationnetwork 14 interconnecting a plurality of components 16, wherein thesoftware architecture 10 resides on at least one component 16 to enablethe component 16, and preferably each additional component 16 has thesoftware architecture 10 in resident, or an alternate able to beinteroperable with. The household appliance 12 also has aninternal/external communications connection 18 shown interconnected tovarious network interface devices 20 for communication with variousembodiments of an external client 22.

The external clients will typically comprise computing hardware andsoftware and networking hardware and software able to interact with thesoftware architecture 10. This may be achieved by including all or aportion of the software architecture 10 within the embodiment of theexternal client or an alternative to the software architecture 10 whichis able to communicate and fully or partially interact with the softwarearchitecture 10. A number of alternate components (C dll, Visual BasicDriver, Java Driver, and Active X driver) able to fully interact withthe software architecture 10 have been implemented.

In connection with the text of this patent application and in review ofthe drawings accompanying the text of this application, it will beunderstood that the abbreviation “SA” refers to “software architecture”as described by reference numeral 10 in this application.

Further, the term “client” is used to refer a component on which all ora portion of the SA resides and which fully or partially enables thefunctionality of the component. The component can be either an internalor external component. While client will primarily be used to describe acomponent enabled by the SA, client is also used to describe a componentthat is enabled by an alternate software that is able to successfullyexchange messages on internal communication network 14 and communicatewith the SA. Generally, the term client is used when referring to thesoftware aspects and not the hardware aspects of the node.

The components 16 can comprise one or more devices. Thus, the term“device” as used in the application can refer to a component or to adevice. The devices can be any electronic, electro-thermal, andelectromechanical elements which collectively form the component orwhich are attached to a component with a controller via electricalcircuitry (e.g., wiring harness), a physical part which can executelogic, and a physical part which has memory.

As described herein, the appliance 12 can be any of the well-knownvariety of appliances which would be well known to one skilled in theart. For example, the appliance 12 can be a washer, a dryer, amicrowave, a dishwasher, a refrigerator, a refrigerator/freezercombination, a stand-alone freezer, a warming drawer, a refrigerateddrawer, an oven, a combination cooktop and oven, a cooktop, and thelike. While the described environment of the invention is that of anappliance, the invention has applicability to any type of machine havingnetworked components.

As described herein, the internal communication network 14 can be anywell-known interconnecting conduit, wiring and/or harness, or wirelesssystem suitable for interconnecting the various internal components 16of a household appliance 12. As described in the background section ofthis application, the WIDE network is a suitable internal communicationnetwork 14 to provide the internal communications necessary to supportthe software architecture 10 according to the invention. It will beapparent to one skilled in the art that the software architecture 10 canrun on any suitable internal network, and that the illustrative exampleprovided herein (i.e. the WIDE network) is simply one example of asuitable internal communication network 14.

As previously stated, component 16 is any processor-based component orsub-component of a household appliance 12. Examples of components 16suitable for receiving and installation of the software architecture 10according to the invention include, but are not limited to, motorcontrol microprocessors, microprocessor enabled key pad controllers, LCDuser interface controllers, and other device controls typically includedwithin a household appliance 12.

The internal/external interface connector or slot 18 is suitable forconnecting a plurality of types of devices 20, which are able tocommunicate on the internal communication network 14 and at least oneother network such as RS-232 serial, various forms of wireless (Zigbee,Wi-Fi, etc), USB, or wired Ethernet, etc. The functionality of thedevice 20 may be strictly limited to protocol and physical layerconversion, or my be expanded to support value added services inaddition to its base protocol bridging function.

Examples of external clients 22 to which the software architecture 10permits a household appliance 12 to be connected include, but are notlimited to, a personal computer-based control development, a factorytesting application, a diagnostic application, a field test application,and an interface to a connected home environment. This connection to theexternal environment, whether adjacent to or remote from the appliance12, enables value-added applications to communicate with the appliance12. Some examples are:

-   -   Automated factory test    -   Energy Management applications    -   Engineering development tools    -   Appliance Service and Diagnostic Tool    -   Electronic Controls Manufacturing Functional Verification        Testing    -   Consumer Applications . . . etc.

The system level architecture (mechanical, electrical, and softwareelements participating to achieve a useful purpose of the householdappliance) includes the software architecture 10 and software elementsapart from the software architecture 10. The collection of softwareelements, including but not limited to the software architecture 10,within the microprocessor of a component of the system architecture isherein referred to as a software operating environment 16A. The softwarearchitecture 10 is comprised of three components: a core implementation,an application protocol definition, one or more application programinterfaces (referred to herein as “API” or “APIs” in the plural).

Core Implementation

The core implementation of the software architecture 10 is a collectionof software modules (examples found in FIG. 3 are SACore, SADiscovery,SADAQ, SAPortMemory, SAPollVariable) executing in an appliance controlmicroprocessor. As shown in FIG. 11, the core implementation ispreferably executed in the MAIN loop of the appliance controlmicroprocessor which will be apparent to one skilled in the art. Thecore provides a common application messaging layer over the internalcommunication network 14 and is based on a flexible design enabling thedevelopment of cross-platform connectivity applications. As part of thecore implementation, a core API will exist which will be uniformlyimplemented on each appliance. Moreover, where uniform implementation isnot practical, a discovery mechanism may be used, allowing adaptation bythe client to the non-uniformity.

Application Protocol Definition

A protocol is a standard procedure for regulating data transmissionbetween nodes in a network. Messages are sent across the internalcommunication network in one or more packets of data, which are thenassembled to form a communicated message. There are two applicable areasof definition relative to the software architecture 10.

-   -   1. Packet Definition: is the pre-defined meaning for each byte        within a collection of bytes which make the packet, or bits or        bit ranges within one of those bytes therein. FIG. 4 and FIG. 24        and their accompanied description represent the Packet        Definition of the software architecture 10.    -   2. Message Order and Messaging Rules: The definition of a        Protocol is generally expanded beyond the packet definition (1)        above to include rules governing the expected ordered        collections of messages necessary to accomplish certain useful        transactions. Examples of Ordered Messages with Message Rules        (transactions) are shown in FIGS. 6, 9, 27, 29, and 31.

Application Programming Interfaces

An API is a communication and messaging contract, which specifies howone network node communicates with another. This is accomplished bydefining the available function calls, the arguments to each functioncall, the data type of each argument, and in some cases, the validvalues of each argument.

In many cases, APIs are specific to an application or appliance 12, andtherefore are not considered as part of the software architecture 10collection of Core (standard set of) APIs; rather, the softwarearchitecture 10 core enables and exposes multiple API's to the client16, 22, and possibly 20.

System-Level Architecture

The software architecture 10 was designed to achieve several objectivesover time.

-   -   1. Business productivity within the constraints of existing        control architecture.    -   2. Business productivity though enablement and realization of        new control architecture.    -   3. Support and better enable core business functions of        Innovation, Manufacturability, Quality, and Serviceability.    -   4. Enable new growth opportunities by enabling production        appliances with the software architecture 10 which with the        addition of the connector 18 creates the ‘connectable’        appliance. This approach minimizes the risk and cost of        connectivity by externalizing the cost of networking        electronics.

To realize the full potential of this architecture, a simple connectorcan be available on the appliance 12 so that a network card can beplugged into the appliance. See FIGS. 1 and 18-22 for examples ofsuitable external NICs 20 connected to the appliance 12. As theappliance 12 already has an internal, low cost network 14 for itsinternal purpose, additional wiring to connect the internalcommunication network 14 with the external NIC 20 via aninternal/external interface 18 is minimal and can be accomplished in aknown manner, such as by a three-wire serial cable, an externalconnector, and a mounting fixture.

The software architecture 10 can preferably reside on all components 16of the household appliance control system. However, where cost or otherconstraints are prohibitive, the software architecture 10 can reside ona sub-set of the components 16 within the control system of thehousehold appliance.

Example benefits of this “connectable” architecture include, but are notlimited to: external NICs 20 can be added after market, reducing basecost of the appliance 12. NICs 20 can be developed supporting multiplenetwork technologies, applications and NICs 20 can be cross-platform andgeneric due to the standard interface presented by the softwarearchitecture 10, an internal low-cost network (such as the WIDE networkexample) is used as a standard, API framework and discovery allows manyvalue added commands, the software architecture 10 uses bounded eventsto preserve state and make efficient use of bandwidth, and the softwarearchitecture 10 is designed to be configured at runtime allowing programdevelopers a more flexible architecture that can reduce time to market.

FIG. 2 is a schematic illustration of the internal communicationsnetwork 14 of FIG. 1 showing the software architecture 10 according tothe invention interposed between the internal communications network 14and various software components 16B within the software operatingenvironment 16A internal to the components 16 making up the controlsystem for the household appliance 12. The components 16 in FIG. 2represent typical components found in appliances 12, such as anappliance manager (main board or motherboard) and another component suchas motor control and a control panel or keypad interface, generallyreferred to as a user interface. The “Energy” and “Diag” indicia in FIG.2 are examples of typical non-core functions performed by the softwarearchitecture, such as energy and power management (“Energy”) andtroubleshooting or diagnosis (“Diag”). Not explicitly shown in FIG. 2,are core functions (API 1-7 and 10) performed by the softwarearchitecture and represented by the indicia 10.

In addition, the software architecture 10 can be extended to many othertypes of system architectures where data exchange over peer-to-peercommunication is desired. These include multi-node systems wheremultiple PCBs such as a motor control, appliance control, and smartsensor boards communicate within the appliance 12 using the softwarearchitecture 10. The software architecture 10 discovery protocolillustrated in FIG. 6 (and described later herein) can be used to enablea component 16 whose presences causes other components 16 to adapt theircontrol functions to create new behavior or performance or expose newcapability to the consumer. The component architecture of FIG. 2(structural model) along with the discovery behavior of FIG. 6 alongwith the component identification scheme of API ID, Type, Version (seeAPI ID=3) are a basis for the invention embodied in 10 to enable theappliance with a new dynamic and intelligent system architecture.

FIG. 3 is a schematic illustration of the internal communicationsnetwork 14 of FIG. 1 showing typical appliance control components 16exchanging messages via the internal communications network 14 of thehousehold appliance 12 comprised of a lower layer protocol, WIDE beingan example thereof, which accounts for OSI layers of PHY, LINK, andpartial Network layer functionality and a higher layer protocolsupported by the software architecture 10 (which accounts for OSI layersof Application, Transport, and partial Network layer functionality)according to the invention. The lower layer protocol functions as both aphysical and link layer between the higher layer associated with thesoftware architecture 10 and the components in the appliance. In thisway, the software architecture 10 uses the lower layer protocol tocommunicate with a first software operating layer 17 that implements thecontrol logic of the controller 16 relative to client 22, as well asusing a second software layer 19 to bypass the control logic anddirectly control the devices associated with the control 16. The devicesin FIG. 3 are the physical elements that represent the functionality ofthe control component 16. FIG. 3 illustrates the control architecture 10from a software/protocol stack perspective.

In addition, FIG. 3 provides a schematic illustration of two modes ofoperation enabled by the software architecture 10 which control theaccess to and the level of intervention between the network messagesexposed by the software architecture 10 and the internal RAM and EE andother forms of non-volatile memory of 16A as well as the Output DeviceLayer, which is a low level software operating layer 16B residing within16A and providing direct control of the devices electrically connect tothe component. The Output Device Layer 16B having direct control of thedevices do so by having direct access to the micro-processor portaddress memory, which, in turn, maps to the physical pins of themicro-processor which, in turn, are connected through various electronicapparatus to the electro-mechanical devices.

Software Operating Layer 1 of FIG. 3 represents appliance specificsoftware components 16B which interface the network messages received bysoftware architecture 10 to the Application Control Logic resulting inthe Application Control Logic to take some action. When the appliance isin a Development State (switch labeled A in FIG. 3), an additionalSoftware Operating Layer 2 (comprised of API 5 (low level API) and API 7(the memory/Port API) and their implementations and Alternate Logic)enable the network messages of API 5 and API 7 to change the state ofthe physical memory of 16A and the devices. In this way, the devices andmemory can be controlled independently of the application software,which typically controls the devices and memory in accordance with anoperational cycle of Software Operating Layer 1. This direct controlpermits the each function of the devices to be independently controlled,which is very beneficial in development or diagnostic processes.

Software Operating Layer 2 is enabled to effect state change by aspecial network message exposed by software architecture 10 and alsoadditional logic which is customized for the various states of theappliance (example shown in FIG. 7). During development state, it ispreferred that when the user interacts with the appliance via the userinterface of FIG. 3, software operating layer 1 will not receive theassociated user interface inputs. Instead, software operating layer 2will receive the inputs from the user interface. Subsequently, softwareoperating layer 2 may interact with the Alternate Logic of FIG. 3. TheAlternate Logic may in turn make function calls onto the Control Logicof Software Operating Layer 1, change values in memory, or change thestate of the attached plurality of devices. However, during developmentstate Software Operating Layer 1 is not able to effect the state of theuser interface (LEDs, lamps, buzzers, text and graphic displays, etc).Development State renders the Control Logic of Software Operating Layer1 ineffective unless invoked from Software Operating Layer 2. DuringDevelopment State, the implementation logic of API 5 and 7 and theAlternate Logic are in complete control of the Appliance 12 and itsassociated componentry.

Development State reverts back to the Idle State (of FIG. 7) when aspecial network message is received. In addition, it is contemplated,that at least one pre-determined key press of a sequence of key pressesmay also result in a transition from Development to Idle state.

Software Operating Layer 1 operates independently of the enablement ofOperating Layer 2. The purpose of the development state is to allow andenable operational cycles that were not previously contemplated. Theadvantage to this approach is that implementations and configurations ofthe appliance, some of which are illustrated in FIG. 1, do not requirenew software modifications to any component 16 of the appliance becausethe appliance has the capability through the software architecture 10 tosupport any implementation or configuration contemplated.

There are many uses for this capability. They include but are notlimited to:

-   -   1. ability to add new functional componentry to an appliance        enabled with software architecture 10 achieving new behavioral        characteristics and cycles of operation without modification to        the pre-existing functional componentry. Examples of this are:        -   a. adding steam control to a washer, dryer, oven, and            microwave        -   b. adding energy and other resource management componentry            to an appliance        -   c. adding networking componentry enabling connections to            external networks in addition to the internal network 14.        -   d. adding a card reader to a commercial appliance in order            to create a pay for use usage model.        -   e. adding a memory device which comprises additional cycles            of operation available for selection and invocation by a            client node or application or a user interacting with a user            interface.    -   2. performing diagnostic tests, which can be accomplished by        actuating each output sequentially to verify the expected        results (examples: heater on—observed temperature increase, fill        valve on—observe water level rise, ice crush motor—observe        rotation of crushing apparatus)    -   3. performing automated factory tests    -   4. performing automated performance testing and DOE executions    -   5. performing automated lifecycle testing    -   6. performing component 16 unit testing and automated regression        testing    -   7. performing automated ECM testing    -   8. performing other forms of ad hoc debugging and testing    -   9. enabling an alternate client device (example: PC) to control        the Appliance 12 allowing the universe of selectable cycles of        operation to be developed and tested using alternate software        operating environments 16A to that which is typically required        on the final production embedded computing componentry 16 which        offer more productive programming environments resulting in a        reduced time to market for new appliance models.

FIG. 4 is a schematic illustration of a packet structure 24 for theinternal communications network 14 of the household appliance 12 shownin FIG. 1 having a payload portion 26 comprising an application packetstructure 28 for the software architecture 10 according to theinvention. Packet structure 28 represents a well formed message whichthe software architecture 10 can create and send to other components 16and 22 (having an occurrence of the software architecture 10 or avariant of the software architecture 10 which has been designed to beoperable with packet structure 28) for the purpose of a meaningfulexchange of data. Packet structure 28 occupies the position 26 withinPacket structure 24, but packet structure 28 could occupy an alternateposition in a variant of packet structure 24. 28A represents a packetstructure within 28 which is defined according to the values of API Idand Op Code of packet structure 28.

In a network protocol, a packet (sometimes called a message) is acollection of bytes which are transmitted sequentially, representing allor part of a complete message. Generally, it is composed of a header,which includes routing information, a body (also referred to as“payload”) which is data, and a footer which sometimes contains achecksum (i.e., a CRC sum) or a terminator, such as an “end” flag. Thepayload is a collection of bytes contained in a packet. The payload isthe data being transmitted between the application layers of two nodes16. The function of the network and the protocol is to get the payloadsfrom one node to the other. Sometimes one protocol is sent as thepayload of another, and in this way, protocols can be nested or stacked.Variables are named memory locations, which have associated values. Oneor more variables can comprise the payload. A transaction is a series ofmessages or packets that represent a complete data exchange between aplurality of nodes.

The relationship between a packet and a payload can have an impact onthe efficient use of available bandwidth. The tradeoff to be consideredis the amount of overhead needed to get the payloads from one node toanother in the context of application layer requirements.

The protocol packet structure 24 as a first header byte which isidentified by example as 0xED, followed by an address byte having fourportions. The first portion of the address byte comprises a destinationportion (D) of bits 0, 1, 2. The second portion of the address bytecomprises a broadcast portion (B) of bit 3. The third portion of theaddress byte comprises a source portion (S) of bits 4, 5, 6. The fourthportion of the address byte comprises a reserved portion (R) of bitseven. The address byte is followed by an identification byte comprisedof a service data unit length (SDU-L) comprised of bits 0-3 and a SAPidentifier comprised of bits 4-7. SAP identifier defines the structureof the enclosed Payload 26. A SAP of 4 indicates that the enclosed SDU26 is defined by the packet structure 28 associated with the softwarearchitecture 10. The identification byte is followed by a service dataunit which is generally referred to as the “payload” of the protocolpacket structure 24 and is identified generally by reference 26. Thepayload 26 is followed by a standard validation byte, such as ahigh-byte, low-byte combination or generally referred to by thoseskilled in the art as CRC16-CCITT.

The application packet structure 28 is formed from the payload portion26 of the protocol packet structure 24. It is within this applicationpacket structure 28 that the communications protocol and data exchangepermitted by the software architecture 10 is carried out. The first byteof the application packet structure 28 contains an identifier (API ID),an integer from 1-255, of the particular API carried by the particularinstance of the application packet structure 28. The second byte up theapplication packet structure 28 contains in operation code (abbreviatedherein as “op code”) as an integer from 1-31 in bit 0-4, followed by acommand or feedback (Cmd/Fb) flag of bit 5, a fragmentation (Frag) flagof bit 6, and a more messages pending (MMP) flag in bit 7. Bytes 3-15 ofthe application packet structure 28 comprise the payload (i.e., messagedata) of the particular instance of the application packet structure 28.

Essentially, the software architecture 10 uses two bytes of the payload26 of the network packet structure 24 of the internal communicationnetwork 14 for additional protocol. The API ID is a unique identifierfor a collection of Op Codes which are organized into functional units.0xFF (255) and 0x01(1) are preferably reserved. An Op Code is a uniqueID within an API which defines and identifies a single command orfeedback message. Each API has an associated Type (2 bytes) and Version(2 bytes) allowing for a large library of identifiable, functionallyrelated groups of messages (op codes) to be created over time.

Preferably, x1F (31) is a reserved value for Op Code. The Cmd/Fb flagindicates whether the message is a classified as a command or afeedback. A command is some message that requests an action to be taken,where a feedback is some message that simply contains information(acknowledgement, event data, etc . . . ). Preferably, the Cmd/Fb flagis 0 for commands and 1 for feedbacks.

The Frag flag specifies whether the received message is being brokeninto multiple messages (fragments) by the sender because of the sizelimitations of the lower layer protocol's SDU 26. The first fragment ofthe message will take on the structure of FIG. 4. All subsequentfragments of the message will take on the structure of FIG. 24. The Fragflag is preferably set until the fragmented message is completed.

The MMP flag indicates that events are sent as individual messages butare bounded together by protocol so that the client can group eventstogether as a complete snapshot for one scan of the micro-controller.The MMP flag is preferably set until the last message for a snapshot issent out. FIG. 9 and the accompanying discussion provides more detail onbounded messages.

The MMP flag provides the software architecture 10 the capability toexpress the state of an appliance 12 as a function of independentlymeaningful feedback variables bounded together in snapshots.

When the internal state of an appliance 12 changes, multiple events maybe sent which, in total, describe the new state of the appliance 12. Thenumber of events required to describe a state change is appliance 12state specific. Therefore, special protocol delimiters are used to allowan implementation specific number of feedback variables to be associatedwith a particular appliance state change. Because these events areindependently meaningful, this approach is preferable in that allpermutations of event (data) aggregations can be created through the useof MMP. This results in efficient use of the identification namespace(API Id and Op Code) because no new identifiers are required when theclient requires a new combination of data to be sent. In summary, MMPand the associated rules thereof, allow dynamic and virtual dataaggregation eliminating the need for special application case specificsolutions. In FIG. 9, the net effect of the MMP flag is shown.

The MMP flag also provides the capability for the embeddedimplementation to suppress the invalid transient condition. As theappliance state transitions, it is possible for a set of relatedvariables to change several times very rapidly. When appliance state isexpressed in terms of independent feedback variables sent as separateevents (feedback messages) without a binding mechanism, ambiguous orinvalid transient states are likely to occur. Moreover, if the client isexecuting business logic during the invalid transient state, logicerrors may result in incorrect control or user display actions. Refer tothe section hence, labeled State Integrity, for an example of howasynchronous data collection is an inferior approach to data collectedsynchronously within each scan of the microprocessor and transmittedwithin the snapshot enabled by MMP. In addition, message binding can beused to group independent command invocations so that they may beprocessed in batch.

The application protocol 28 also governs incoming messages. In general,networks allow asynchronous processes to communicate, creating thepotential for one network node to exceed the processing capacity of theother by sending too many requests within a short time window. Toprevent message overruns, a protocol is used, according to theinvention, which allows the sender to wait for an acknowledgement beforesending a second message.

This feature permits the software architecture 10 to use an enumerationfor this acknowledgement based on the execution state 8 of the softwarearchitecture 10. In this way, necessary information describing messagesuccess or failure is communicated with fewer messages. The commandsender will receive an enumerated acknowledgement for each command sent.The most common is a positive ACK, which means that the node is ready toreceive its next command. All other enumerations are a form of failure.Failure is characterized by the remaining 254 possible values of theAcknowledgment byte. Of this range of 254 values, some are standardizedand some are reserved for application specific failure codes.

Frag and MMP allow the user of the software architecture 10 flexibilityin designing the application messaging strategy. If a developer choosesto use very large messages, Frag can be used so that messages largerthan the payload 28A (i.e., 13 bytes within the exemplary applicationpacket structure 28 shown herein) can be sent by sending the originallarge data set as multiple smaller data sets within multiple packets ofstructure 28.

By the same token, if a developer chose to use smaller messages (whichare often the case) but wanted to group those messages together, MMP canbe used. For example, if 10 messages of 3 bytes each needed to be sendas a group so that the client application could know that the messageswere related to the same scan of the micro-controller, then the first 9messages would have MMP set and the last message of the group would haveMMP=0.

The following presents a summary of defined APIs for the softwarearchitecture 10 and then each one of these commands and feedbackmessages is described in detail. The advantage of this approach is thatit allows the developer to choose the modules within the softwarearchitecture 10 that are appropriate for the current stage ofdevelopment (i.e., unit test, engineering testing, production, etc).Furthermore, compiling out certain modules allows developers to useportions of the software architecture 10 in those cases were RAM/ROMresources would otherwise be prohibitive. The APIs are described withtheir currently-selected application program interface identifier (APIID), however, any identifier can be employed without departing from thescope of this invention. The associated functions made capable by theparticular API are enumerated beneath each API. Bulleted functions (“Ω”)are feedback messages which are sent from the software architecture 10to the client (such as an internal client 16 or an external client 22)and non-bulleted functions are commands which are sent from client (16,22) to the software architecture 10.

One note on a convention used in this application. The word “extends”refers to the ability of one API to build on the functionality of abaser-level API. The extends keyword means: When API x ‘EXTENDS’ API y,then API x=API x+API y. This notation simplifies the task of recordkeeping and API documentation. In other words, API x also includes thosefunctions specified in API y. If API x and API y each specify a functionwith the same Op Code, the implementation of API x implementation cantake precedence.

The following table describes the Core API (API ID=1): MessageAcknowledgment Publish Heartbeat Set Heartbeat Period New HeartbeatPeriod Read Memory Publish Memory Data Read EE Publish EE Data SendEvent(s) Publish Event

The following table describes the basic data acquisition API

(Basic DAQ, API ID=2, Type=1): Create Numeric Event Create Byte EventClear Event(s) Publish Events Cleared Reset SA Publish SA Reset SetExternal On Publish External On Set External Off Publish External Off

The following table describes the extended data acquisition API

(Extended DAQ, API ID=2, Type=2):

The extended DAQ is inclusive of the Basic DAQ at runtime. Get EventData Publish Numeric Event Data Publish Byte Event Data Create RemoteNumeric Event Create Remote Byte Event Get Remote Variable Data PublishRemote Variable Data

The following table describes the Discovery API (API ID=3): Find NodesPublish Node Get APIs Publish APIs Get API Info Publish API Info GetInstance Info Publish Instance Info

The following table describes the Core Debug API (API ID=4): PublishSaturation Register for Saturation Message

The following table describes the Low Level API (API ID=5): SetDevelopment State Publish State TBD (Appliance Specific)

The following table describes the Core Key Press API (API ID=6): PressKey (key index) Publish Key Press (key index)

The following table describes the Core Memory/Port API (API ID=7): WriteMemory Write EE

The Energy Management API is API ID=8. As does the other APIs, theEnergy API is made of a collection of Op Codes, each representing auseful function relating to energy management, and having an associatedcollection of bytes which are the appropriate parameters to achieve thefunction.

The following table describes the Poll Variable API (API ID=10): ReadPoll Variable Publish Poll Variable

The Core API (API ID=1 herein) is the smallest subset of the softwarearchitecture 10 functionality that can be deployed. However, it iscontemplated that other embodiments compliant with packet structure 28may be developed. It makes provisions to design the two hard coded dataacquisition schemes referenced in FIG. 5.

In the Core API, a protocol mechanism, send Events of FIG. 5, allows theclient (16, 22) to request the event source to send all or send aspecified set of events. In this way, a type of polling is possiblewithin the framework of the eventing architecture without separatemessage definitions or implementation structures and logic. Moreover,this mechanism enables robust system startup conditions. For example: ifall network nodes send all events simultaneously at system power up,misoperation within the software of a client 16 or 22 where the softwarecomponents therein would not be able to accurately process the pluralityof messages generated as a result of a power-up condition are morelikely.

The DAQ API (API ID=2) presents a dynamic mechanism query for acomponent 16 enabled by the software architecture 10. This featureallows the client 16/22 to configure an embedded software engine (anarray of structures whose elements are instanced and stored in a dynamicmemory heap [see DynamicMemoryHeap of FIG. 33 containing a collection ofNVOEvent structures]) which associates a section of microprocessormemory with an event operator (described in a table below) andarguments. Pointers into memory, values of the memory, event operatorsand operator arguments are stored in the memory heap's array ofstructures [FIG. 33 Heap[ ] containing NVOEvent structures]. As shown inFIG. 5, the DAQ engine can be configured in 2 ways:

1 Application software apart from the software architecture 10 whichresides in the same microprocessor can configure the DAQ 30 as is shownby the arrow in FIG. 5 from the DAQ Init( ) software component.

2. Secondly, external clients may use the DAQ API (described herein) toconfigure the DAQ from the network 14.

The rational for each method of DAQ configuration is discussed 3paragraphs hence.

As shown in the Process DAQ Events State Diagram of FIG. 36, when theDAQ engine is executed, it iterates over each event structure, checkingthe associated memory locations against the event operator andarguments. When the event conditions evaluate to a TRUE, message buffersare constructed within the internal memory reflecting the dataassociated with the event condition. When the iteration is complete,notification messages are generated and preferably broadcast to thenetwork. Alternatively, notification messages can be directed to aspecific component 16 if additional memory is allocated to store thenetwork identifier of the component which initially requested orconfigured the event.

A developer can use several event operators. Examples include: onchange, greater than, less than, equal to, deadband, bitmask, etc.Several Op Codes of the DAQ API are provided to control the memory heapat runtime such as: clear Events, add Events, External notificationon/off, get Events, get Event Data, etc.

In total, the software architecture 10 supports four schemes for datacollection (all of which are shown in FIG. 5). Two of the four schemes,describe briefly above, are reliant on the DAQ. The other two schemes,also briefly described above, are hardcoded. Each scheme can co-existwithin the software architecture 10. Each scheme provides certainoptimizations at the expense of other resources.

1. In a client-configured data acquisition scheme, dynamic events arecreated. This method can be used if the microprocessor has enoughRAM/ROM capacity and is most commonly used when the client is a PCapplication. Using the DAQ API, a developer can re-use code, requireless engineering time, leverages a proven re-useable eventing module, isflexible (e.g., can be configured at runtime), and there can be anoptimization of network bandwidth. However, this method can require moreRAM/ROM than hard coded methods and an embedded client might not haveaccess to needed data files at runtime.

In the client-configured data acquisition scheme, the DAQ engine 30 mustbe provided a memory location in order to watch for an event. With avariable map, this is practical when the client is a PC application asin FIG. 26A. However, when the client is, for example, another controlboard that implements the software architecture 10, access to a variablemap is impractical. Thus, this invention provides functionality for anembedded variable map located in the memory of a node implementing thesoftware architecture 10. This variable map links an API and Op Code toa variable address as in FIG. 26B. Thus, in order to register for anevent on said node, the client needs only know the API and Op Code forthat variable, not the specific memory address.

Using the embedded variable map in the client-configured dataacquisition scheme, the situation may arise where a particular client isrestricted from creation of an event because the associated API and OpCode pair has already been registered by another node. In such asituation, this invention provides that node the ability to requestinformation about the embedded variable map. Included in thisinformation is the variable's memory address. With this information, theclient node can the register for an event of the same variable using thevariable's address and a different API and Op Code pair than previouslyattempted (see FIG. 27).

2. An alternative to the client configured DAQ, is a self configuredDAQ. In this case, the internal logic uses the DAQ engine to createNVOEvent structures in the DynamicMemoryHeap of FIG. 33. This can be auseful scheme when the events to be realized are fixed and are known atthe time of design and there are enough RAM and ROM resources to reusethe difference engine (the logic contained within the DAQ 30) of the DAQ30. Therefore this method has similar benefits as the client-configureddynamic event scheme, and moreover, will require more RAM/ROM than hardcoded methods (described below).

3. In a hard-coded eventing module, a developer can optimize networkbandwidth, optimize use of RAM/ROM and can conform to the DAQ API.However, this scheme requires a custom-coded solution to generate theevents and does not rely on the software and logic of the DAQ 30 asshown in FIG. 36).

4. Using the hard-coded polling method provided by the Core API, adeveloper can optimize use of RAM/ROM by creating custom-coded solution.Polling will generally waste network bandwidth, but is sometimes useddue to its simplicity.

FIG. 5 illustrates one example of each type of potential dataacquisition method. An installation of the software architecture 10 cansupport one, some, or all of the 4 methods. Each of the installation 10and the client 16 may have a DAQ API initialized thereon. The softwarearchitecture 10 may have one or more hard-coded polling variables, oneor more hard-coded events, and/or a DAQ engine 30 as described. Variousvariables and events are transmitted between the main softwarearchitecture installation and the client. For example, varioushard-coded polling variables are exchanged between the softwarearchitecture 10 and the client 16 by the read Poll Variable and publishPoll Variable methods. Various hard-coded events are exchanged betweenthe software architecture 10 and the client 16 by the send Event andpublish Event methods. A create Event method is called by the DAQ Initengine which is sent to the DAQ Engine 30 which, in turn exchanges agenerated event with the client 16 by the send Event and publish Eventmethods. The DAQ engine 30 in the software architecture 10 can alsocreate an event received via a create Event method received from theclient 16.

FIG. 5A is a schematic illustration showing communication between ahousehold appliance 12 having the software architecture 10 installedtherein according to the invention and shown in FIG. 1 and a client 16at a remote location, such as a customer call support center as shown inFIG. 5A. The appliance 12 has an interface 18 to its internal network 14and a network interface 20 which allows it to communicate with theexternal client 22. The schematic of FIG. 5A shows the customer servicecenter setting up a variable watch using the DAQ Engine 5 create Eventfunction and diagnosing a trouble with the household appliance 12without needing to send out a service truck to the residence.

The software architecture 10 can be customized to allow for the needs ofdifferent implementation platforms. RAM and ROM space and timecomplexity can be managed, as well as access to memory locations, andtimeouts. All of these are located in a predetermined parameters file.It will be understood that the parameters can be renamed, changed,retyped, added or deleted without departing from the scope of thisinvention.

The Discovery API (API ID=3) enables the concept of “Plug 'n Play”architecture. The Discovery API implies that a physical network node orclient 16 can contain n functions, each encapsulated by a known API witha unique ID, Type, and Version. These APIs are portable (meaning theyrepresent functionality and are independent of the microprocessor,software language, and network topology) and re-useable on othercomponents where the functionality therein is applicable. The Discoveryprotocol (described in API 3 of FIG. 6) allows the client to learn theassociations between the components 16 and the groups of functionality(APIs) which they contain.

FIG. 6 illustrates a typical Discovery API sequence. Having nostructures in memory representing the other software architecture 10enabled components, a client 16, 22 transmits a command to locatecomponents 16 within the appliance which are enabled with the softwarearchitecture (by issuing a “find Nodes” command). Enabled componentsrespond that they are, indeed, enabled (by issuing a broadcasted“publish Nodes” command). Then, the client 16 transmits a command toidentify which APIs are located on each enabled node (by issuing a “findAPIs” command). Each enabled node responds with a bounded messagecontaining its API IDs (by replying with a “publish APIs” message).Then, the client 16, 22 issues a command to identify information abouteach of the APIs found on each enabled node (by issuing a “get API Info”command). Each enabled node responds with a bounded message (whosepurpose and structure are described in FIG. 9) containing informationabout the API contained therein (by replying with a “publish API Info”message). This message can include type, version, and the number ofoccurrences (or instances) of a particular API Id. In cases where thenumber of instances of a particular API within a single component 16exceeds one (meaning there are multiple of the same APIs installed on acomponent 16, such as in the case of a multiple-cavity oven which mightuse multiple oven control APIs), the client 16 issues a command to getinformation on each instance of an API (by issuing a “get Instance Info”command). The software architecture 10 responds with the requestedinformation (by the “publish Instance Info” message). Multiples of thesame instance are auto-numbered with a pseudo-API ID by the softwarearchitecture.

In addition when a component 16, enabled by the software architecture 10and having resident the sub-component of the software architecture 10Discovery which is API Id=3, initializes it will automatically send outa message announcing itself (API Id=3, Op Code=2 publishSANode( )).

Also, if the user of the software architecture so chooses, the Discoverysequence of FIG. 6 may be altered by omitting messages 1 and 2 (op codes1 & 2 respectively). The approach is valid in that the client mayinitiate discovery by issuing an Op code=3 message, getSAAPI(collection) which will result in responses from all components enabledby the software architecture 10 thus obviating the need for messages 1and 2 in most cases.

It is also contemplated that an abbreviated messaging sequence couldachieve the same results as the aforementioned discovery sequence. In anabbreviated discovery sequence, each node issues a message afterpower-up containing within one message the totality of information whichwas described in the aforementioned discovery sequence. Each nodereceiving this message would reply back with the same information aboutitself giving the node which just powered up the discoverableinformation from all the nodes that were already powered up.

This Discovery API protocol mechanism allows a client 16 to locate alogical entity at runtime without prior compile time programming.Moreover, this mechanism allows the client 16 to determine if expectedcomponents are resident or missing. From this knowledge, the client canconfigure itself and/or present the user with the appropriate inferredfunctionality.

The Low Level API (API ID=5) exposes via the network 14, capabilityallowing the client to control (actuate) the output devices which areelectrically connected to the containing component 16 and to provideread and/or write access to the numeric value which represents thecurrent state and potentially the state history of the electricallyconnected input device. Typical examples of outputs are valves, relays,triacs, solenoids, LEDs, lamps, buzzers, and so on. Typical examples ofinputs are push buttons, switches, sensors (e.g., pressure, temperature,and over-temperature), and so on. In the preferred embodiment, the LowLevel API as well as the Memory—Port API are available only in the‘Development State’ of FIG. 3 of the software architecture 10 of theappliance 12. ‘Development State’ can only be entered from the appliance12 ‘Idle State’ of the exemplary Appliance state diagram of FIG. 7. Alsoin the preferred embodiment, if any user interface actions are initiatedvia a keypad, LCD, or other user interface device of the appliance 12during ‘Development State’, the appliance 12 can revert back to the‘Idle State’ of FIG. 7 and setting each output back to its un-actuatedstate. The messages for initiating ‘development state’ can be found inthe message definition specification for the Low Level API. (See API 5,Op Code 2). This network message is defined to allow the appliance 12 toenter the development state. In development state, a special API isenabled and exposed to the network 14 which allows the client 16 tocontrol the electronic outputs of the appliance 12 directly. Indevelopment state, production oriented business rules such as validationare by-passed giving the client 16 complete control of the electronicsub-system.

The Low Level API can be used to implement non-standard operation of theappliance in that the appliance can be operated in a manner other thanin accordance with one of the predetermined operating cycles implementedby the appliance software operations layer, which typically resides onthe main controller. In this way, the Low Level API can be thought of asenabling additional cycles of operation. Some examples of additionalcycles of operation include: a demonstration cycle; a development cycle;an error detection cycle; a diagnostic cycle; a cycle that reduces thetime of at least one timed step of one of the predetermined cycles ofoperation; a cycle that bypasses at least one operational step of one ofthe predetermined cycles of operation; a cycle that substitutes a timedstep for a step that responds to an event of one of the predeterminedcycles of operation; and a cycle that exposes the low level API to thenetwork

The Key Press API (API 6) allows the client 16 to press virtual keys.This provides an equal method by which to exercise and test the softwarewithout mechanical or human actuation of the physical key pad.

One note on a convention used in this application. The word “extends”refers to the ability of one API to build on the functionality of abaser-level API. The extends keyword means: When API x ‘EXTENDS’ API y,then API x=API x+API y. This notation simplifies the task of recordkeeping and API documentation. In other words, API x also includes thosefunctions specified in API y. If API x and API y each specify a functionwith the same Op Code, the implementation of API x implementation cantake precedence.

Exemplary application packets for the payload portion of the packetstructure for the internal communications network of the householdappliance follow. The application packets are grouped according to API.

Core API: API ID=1 (Type 3, Version 1). The following application packetrepresents a directed message from the software architecture 10 to aclient for publishing acknowledgement (Publish Acknowledgement). Thismessage is sent by the software architecture 10 to the sender of aprevious message. It contains an enumerated value representing theresults of the previous command processed by the software architecture10. Generally, the receipt of the acknowledgment indicates that thesender can initiate the next message. API ID Op Code Byte 3 Byte 4 Byte5 1 1: publish Acknowledgement Reason code API OpCode

Note that the API and op code of the previously received command (theone that is being acknowledged) is contained within byte 4 and 5 of thepayload. This provides the receiver of the acknowledgment (the component16 which sent the original command) certainty as to which previouslytransmitted command is being acknowledged. (The previously transmittedcommand having the unique identifier of API Id and Op Code.) It shouldbe noted that in the drawings and descriptions, the ACK is generallyassumed and is not continuously repeated or documented

Enumeration values for the reason code of the above application packetare shown in the table below. Enumeration Value for Reason Code ReasonCode Name Programming Notes 0 READY* The command was successfullyexecuted and the SA is ready to accept another command. 1 BUSY* The SAmodule is currently busy executing a command. Usually just an internalstate. 2 REJECTED* The command sent to the SA was rejected, becausethere was another command still in process. 3 ACK_EVENT The command wasnot executed because the SA is currently waiting for an acknowledgement.4 UNSUPPORTED The command was unsupported for some reason and did notexecute. (Ready for next command) 5 UNSUP_OP_CODE The command wasunsupported and did not execute due to an invalid op code. (Ready fornext command) 6 UNSUP_UNAVAILABLE The command was unsupported and didnot execute because it is currently unavailable in this state. (Ready) 7UNSUP_INVALID_PARAM The command was unsupported and did not execute dueto an invalid or out of bounds parameter. (Ready) 8 UNSUP_OUT_OF_MEMORYThe command was unsupported and did not execute because the dynamic heapis out of memory. (Ready) 9 UNSUP_DOOR_OPEN The command was unsupportedand did not execute because the appliance door was open. (Ready) 10UNSUP_BOUND_CMD_INCOMPLETE The bounded command was not fully receivedbefore a specified timeout, so it was not fully executed. (Ready) 11UNSUP_CANNOT_PAUSE_NOW Unable to pause due to state of applianceprocess. 200-255 Application Specific Application Developers may usethese return values in their applications. It is up to the Developer todocument the Application Specific reason codes.*0-3 are reserved for use by the software architecture 10

The following application packet represents a broadcast message from thesoftware architecture 10 to a client (16 or 22) for publishing heartbeat(Publish Heartbeat). This message is periodically sent by the softwarearchitecture 10. This allows nodes, which have registered for events, tomaintain confidence in the event sources. In other words, heartbeatinsures connection integrity. Alternatively, the client (16 or 22) maydetermine that each or some event(s) sent by the software architecture10 should receive an acknowledgement sent by the client back to thesoftware architecture 10 before the software architecture 10 deems thetransaction associated with the generation and transmission of the eventto be complete. If a particular event has been created with the‘acknowledgment’ classifier according to the message specification ofAPI 2, Op Code=1, 2, 12, or 13, the software architecture 10 will definethe end of the transaction associated with the generation andtransmission of the event to be complete when an acknowledgment messageis received according to the message specified by API Id 1 and Op Code1.

Publish Heartbeat will not be sent until after the software architecture10 receives a command. This can be used to prevent a Traffic Stormcondition during power-up. (Traffic Storm refers to a misoperationwithin the software of a client 16 or 22 where the software componentstherein would not be able to accurately process the plurality ofmessages generated as a result of a power-up condition.) PublishHeartbeat will be suspended after a Reset SA message, which is describedbelow with respect to the Core DAQ API and Op Code 8, is received, butwill resume after the next subsequent command. This is a feedbackmessage. API ID Op Code Byte 3-Byte F 1 2: heartbeat

The following application packet represents a directed message from aclient to the software architecture 10 for setting heartbeat period (SetHeartbeat Period), which is setting a frequency at which the heartbeatmessage is sent by the software architecture 10. Exemplary frequenciesrange from 0 seconds (off) to 3600 seconds (1 hr). API ID Op Code Byte 3Byte 4 Byte 5-Byte F 1 3: setHeartbeatPeriod Sec Sec MSB LSB

The following application packet represents a broadcast message from thesoftware architecture 10 to a client for publishing the heartbeat period(Publish Heartbeat Period). This message is a response to Set HeartbeatPeriod. It is necessary so that if a second client changes the heartbeatperiod, the first client will be notified. Clients who requirenon-changing heartbeat periods should use the DAQ API to set up an eventwith a constant broadcast operator, See DAQ API Id=2, Op Code 1, Byte9=4, 5, or 6 (see change operator table). API ID Op Code Byte 3 Byte 4Byte 5-Byte F 1 16: newHeartbeatPeriod Sec Sec MSB LSB

The following application packet represents a directed message from aclient to the software architecture 10 for reading memory, particularlythe RAM (Read Memory). It is sent to the software architecture 10 andresults in a “Publish Memory Data” response, which is shown below (OpCode 4) and contains values specified in Bytes 3-7 of the packet below.API ID Op Code Byte 3 Byte 4 Byte 5 Byte 6 Byte 7 Byte 8-Byte F 1 5:readMemory Address Address Address Size MSB Size LSB Hi-byte Mid-ByteLow-Byte

The following application packet represents a directed message from aclient to the software architecture 10 for reading EE memory (Read EE).It is sent to the software architecture 10 and results in a “Publish EEData” response (Op Code=8), which is shown below and contains the valuesspecified in the Read EE packet, Bytes 3-7 below. API ID Op Code Byte 3Byte 4 Byte 5 Byte 6 Byte 7 Byte 8-Byte F 1 6: readEE Address AddressAddress Size MSB Size LSB Hi-byte Mid-Byte Low-Byte

The following application packet represents a directed message from thesoftware architecture 10 to a client for publishing memory data (PublishMemory Data) and is a response to Read Memory. API ID Op Code Byte 3Byte 4 Byte 5 Byte 6 Byte n Byte 8-ByteF 1 4: publishMemoryData datadata data . . . data MSB LSB

The following application packet represents a directed message from thesoftware architecture 10 to a client for publishing EE memory data(Publish EE Data) and is a response to Read EE. API ID Op Code Byte 3Byte 4 Byte 5 Byte 6 Byte n Byte 8-Byte F 1 8: publishEEData data datadata . . . data MSB LSB

The following application packet represents a directed message from aclient to the software architecture 10 for sending events (Send Events).The message instructs the software architecture 10 to send specifiedevents regardless of event trigger criteria.

Note: Event Id is used synonymously with Op Code. Event Id is a moredescriptive term for Op Code when describing an Event which is part ofan API.

Note: the notation used below is repeated through out the document andis described here only. If Byte 3 contains the reserved value 0xFF, thenthe software architecture 10 interprets Byte 3 to mean all API Ids.Otherwise, Byte 3 specifies a particular API Id. Likewise, If Byte 4contains 0xFF, the software architecture 10 interprets Byte 4 to meanall Events for the API or APIs specified in Byte 3. Otherwise, Byte 4contains a single Event Id. Bytes 5 through Byte n contain a singleEvent Id. API ID Op Code Byte 3 Byte 4 Byte 5 Byte 6 Byte 7 Byte 8-ByteF client defined client defined data data data . . . data MSB LSB

The following application packet represents a broadcast message from thesoftware architecture 10 to a client for publishing events (PublishEvent) and is a response to the above Send Events message.Alternatively, if the DAQ Engine is being used, this message is sentwhen the event trigger criteria is satisfied. Below, API Id and Op Codeare notated as ‘client defined’. This refers to the assignment made ofAPI ID and Op Code by the createEvent commands (sent by the Client) ofDAQ API (API Id=2) specifically in Bytes 7 and 8 of Op Code 1 & 2 andBytes 3 and 4 of Op Code 12 & 13 API ID Op Code Byte 3 Byte 4 Byte 5Byte 6 Byte 7 Byte 8-Byte F 1 7: send Event(s) API id EventId# EventId#EventId# EventId# (0xFF = all) (0xFF = all)

Core DAQ API: API ID=2 (Type 3, Version 1). The following applicationpacket represents a directed message from a client to the softwarearchitecture 10 for creating a numeric event (Create Numeric Event). Themessage, identified by API Id of 2 and Op Code of 1 or 2 allows theclient to create and configure feedback variables [NVOEvent structuresof FIG. 33]. Byte 7 and 8 are used to assign the identifier (API Id andOp Code) which will be used to populate fields in the publish eventmessage (API Id 1) when the event conditions are such that an eventmessage is generated. Generated event messages are of the form found inthe preceding description of the Core API where the message packet islabeled as ‘Publish Event’. The identifiers API Id and Op Code locatedin bytes 1 and 2 respectively of the Publish Event message. The valuesfound in these bytes can be assigned through the messages defined forthe DAQ API, Op Codes 1 and 2 below. Bytes 3-5 contain the address inthe memory of the software operating environment which will be evaluatedfor the event condition represented by Byte 9 which is an enumeration ofevaluation rules and Bytes A and B which are arguments to the evaluationrules. Byte 6 specifies the number of contiguous bytes which should beevaluated as a single numeric value with respect to Bytes 9, A, and BAPI ID Op Code Byte 3 Byte 4 Byte 5 Byte 6 Byte 7 Byte 8 Byte 9 Byte AByte B Byte C 2 1: createNumericEvent address address address size APIId Event Id Change Change Change ACK'd Event Hi-Byte Mid-Byte Low-Byte1, 2, 4 Operator Val MSB Val LSB 1 = ACK'd 0 = unACK'd

Event operators associated with Byte 9 of the above application packetare discussed in further detail following this section of exemplaryapplication packets and are shown in the table that denotes eventoperators available when creating a numeric-based event. Additionally,byte C corresponds further classification resulting in eitheracknowledged or unacknowledged events (discussed later). See FIG. 29 foran example of the operation of an acknowledged event.

The following application packet represents a directed message from aclient to the software architecture 10 for creating a byte event (CreateByte Event). The messages definitions, identified by API Id=2 and OpCode=1 or 2 allows the client to create and configure feedback variables(events). The message specification for Op Code 2 is similar in intent,but has different implementation details that provide usefulness forcertain application use cases. API Id 2 with Op Code 2 differs infunctionality from API 1 Op Code 1 in that depending on the value ofByte A, either only 1 byte within the range specified by Bytes 3-5 andByte 6 or all the bytes will be evaluated based on Byte 9's changeoperator and Byte B's change value. Whereas in the case of Op Code 1,the specified bytes were evaluated as a single numeric. In the case ofOp Code 2, each byte or a single byte, according to the value specifiedin Byte A, will be evaluated independently according to the changeoperator specified in Byte 9 and the change value specified in Byte B.API ID Op Code Byte 3 Byte 4 Byte 5 Byte 6 Byte 7 Byte 8 Byte 9 Byte AByte B Byte C 2 2: createByteEvent address address address size API IdEvent Id Change byte index Change ACK'd Event Hi-Byte Mid-Byte Low-ByteOperator 0-255 Val 1 = ACK'd 0xFF = all 0 = unACK'd

Event operators associated with Byte 8 of the above application packetare discussed in further detail following this section of exemplaryapplication packets and are shown in the table that denotes eventoperators available when creating a byte-based event. Additionally, byteC corresponds to further classification resulting in either acknowledgedor unacknowledged events (discussed later.) See FIG. 29 for an exampleof the operation of an acknowledged event.

The following application packet represents a directed message from aclient to the software architecture 10 for clearing event(s) (ClearEvent(s)). The Clearing Events message allows the client to clear theevent definitions previously created with either of the create event OpCodes (1 or 2, as shown above). The client can send multiple Clear Eventcommands to the software architecture 10 using the MMP flag ifsynchronization is needed across multiple commands. API ID Op Code Byte3 Byte 4 Byte 5 Byte 6 Byte n Byte 8-Byte F 2 3: clearEvent API IdEventId# EventId # EventId # EventId # (0xFF = all) (0xFF = all)

The following application packet represents a broadcast message from thesoftware architecture 10 to a client for publishing events cleared(Publish Events Cleared) and is a response to Clear Events. The messagenotifies the clients of the software architecture 10 when Op Codes orAPIs are removed from the existing the software architecture nodeinterface. API ID Op Code Byte 3 Byte 4 Byte 5 Byte 6 Byte n Byte 8-ByteF 2 4: publishEventsCleared API Id EventId# EventId# EventId# EventId#(0xFF = all) (0xFF = all)

The following application packet represents a directed message from aclient to the software architecture 10 for resetting the softwarearchitecture 10 (Reset SA). The Reset SA command instructs the softwarearchitecture 10 to re-initialize as if it had just powered up. API ID OpCode 2 8: resetSA

The following application packet represents a broadcast message from thesoftware architecture 10 to notify that the software architecture 10 hasbeen reset (Publish SA Reset) and is a response to Reset SA. API ID OpCode 2 9: publishSAReset

The following application packet represents a directed message from aclient to the software architecture 10 for turning on externalnotification for a specified event (Set External On). The commandinstructs the software architecture to externally notify clients of theevent. See FIG. 28 for an example of the usage of this command. API IDOp Code Byte 3 Byte 4 Byte 5 Byte 6 Byte n 2 10: setExternalEventOn APIId OpCode OpCode OpCode OpCode

The following application packet represents a broadcast message from thesoftware architecture 10 to notify that external notification of thespecified event has been turned on (Publish External On) and is aresponse to Set External On. See FIG. 28 for an example of the result ofthis command. API ID Op Code Byte 3 Byte 4 Byte 5 Byte 6 Byte n 2 10:publishExternalOn API Id OpCode OpCode OpCode OpCode

The following application packet represents a directed message from aclient to the software architecture 10 for turning off externalnotification for a specified event (Set External Off). The commandinstructs the software architecture to not externally notify clients ofthe event. API ID Op Code Byte 3 Byte 4 Byte 5 Byte 6 Byte n 2 11:setExternalEventOff API Id OpCode OpCode OpCode OpCode

The following application packet represents a broadcast message from thesoftware architecture 10 to notify that external notification of thespecified event has been turned off (Publish External Off) and is aresponse to Set External Off. API ID Op Code Byte 3 Byte 4 Byte 5 Byte 6Byte n 2 10: publishExternalOff API Id OpCode OpCode OpCode OpCode

Core DAQ API: API ID=2 (Type 4, Version 1—Extends Type 3, Version 1).The following application packet represents a directed message from aclient to the software architecture 10 for getting event data (Get EventData). Get Event Data instructs the software architecture 10 to senddefinition(s) of specified events. The definition is a mirror image ofthe data sent in the Create Event Op Code messages, which are shownabove as Op Codes 1 or 2 for the Core DAQ API. The software architecture10 will respond with a collection of Publish Event Data messages, whichare shown below. API ID Op Code Byte 3 Byte 4 Byte 5 Byte 6 Byte n Byte8-Byte F 2 5: getEventData API Id EventId# EventId# EventId# EventId#(0xFF = all) 0xFF = all)

The following application packet represents a directed message from thesoftware architecture 10 to a client for publishing numeric event data(Publish Numeric Event Data), and is a response to Get Event Data. Eachevent definition is reported in a separate internal network message andis governed by snapshot rules associated with the MMP flag of 28 of FIG.4. The event definition contains the information specified about theevent in Create Numeric Event. API ID Op Code Byte 3 Byte 4 Byte 5 Byte6 Byte 7 Byte 8 Byte 9 Byte A Byte B-Byte F 2 6: publishNumericEventDataaddress address size = API Id Event Id Change Change Change MSB LSB 1,2, 4 Operator Val MSB Val LSB

Event operators associated with Byte 8 of the above application packetare discussed in further detail following this section of exemplaryapplication packets and are shown in the table that denotes eventoperators available when creating a numeric-based event.

The following application packet represents a directed message from thesoftware architecture 10 to a client for publishing byte event data(Publish Byte Event Data) and is response to Get Event Data. Each eventdefinition is reported in a separate internal network message and willbe governed by the snapshot rules associate with the MMP flag of 28 ofFIG. 4. The event definition contains the information specified aboutthe event in Creation Byte Event. API ID Op Code Byte 3 Byte 4 Byte 5Byte 6 Byte 7 Byte 8 Byte 9 Byte A Byte B-Byte F 2 7:publishByteEventData address address size API Id Event Change byte indexChange MSB LSB Id Operator 0-255 Val

Event operators associated with Byte 8 of the above application packetare discussed in further detail following this section of exemplaryapplication packets and are shown in the table that denotes eventoperators available when creating a byte-based event.

The following application packet represents a directed message from aclient to the software architecture 10 for creating a remote numericevent (Create Remote Numeric Event). The message allows the client oranother module in the embedded system to configure feedback variablesassociated with an existing API and Op Code using an embedded variablemap. Although the number can be 4 bytes, the change value is limited to2 bytes. FIG. 26B illustrates the embedded variable map. FIG. 27 definesthe interaction between 3 network nodes where Node A successfullycreates a Remote Numeric Event on Node B. And where Node C attempts thesame, but through the interaction with Node B, is able to accomplish theintent of the request without duplication of the Identifier (API Id andOpCode). This is accomplished because Node C is able to query Node B forthe address in memory of the initial Identifier so that an alternative(non-duplicated) Identifier may be selected. The alternative identifieris then used to create the Remote Numeric Event by sending (see message8 in FIG. 27) a new message to Node B with the original memory addressand the alternative Identifier. API ID Op Code Byte 3 Byte 4 Byte 5 Byte6 Byte 7 Byte 8 2 12: createNumRemoteEvent API Id OpCode Change OperatorChange Val MSB Change Val LSB ACK'd Event 1 = ACK'd 0 = unACK'd

FIG. 26B illustrates the embedded variable map. FIG. 27 defines theinteraction between 3 network nodes where Node A successfully creates aRemote Numeric Event on Node B. And where Node C attempts the same, butthrough the interaction with Node B, is able to accomplish the intent ofthe request without duplication of the Identifier (API Id and OpCode).This is accomplished because Node C is able to query Node B for theaddress in memory of the initial Identifier so that an alternative(non-duplicated) Identifier may be selected. The alternative identifieris then used to create the Remote Numeric Event by sending (see message8 in FIG. 27) a new message to Node B with the original memory addressand the alternative Identifier.

The following application packet represents a directed message from aclient to the software architecture 10 for creating a remote byte event(Create Remote Byte Event). The message allows the client or anothermodule in the embedded system to configure feedback variables associatedwith an existing API and Op Code using an embedded variable map. API IDOp Code Byte 3 Byte 4 Byte 5 Byte 6 Byte 7 Byte 8 2 13:createByteRemoteEvent API Id OpCode Change Byte Index Change Val ACK'dEvent Operator 0-255 1 = ACK'd 0 = unACK'd

FIG. 26B illustrates the embedded variable map. FIG. 27 defines theinteraction between 3 network nodes where Node A successfully creates aRemote Byte Event on Node B. And where Node C attempts the same, butthrough the interaction with Node B, is able to accomplish the intent ofthe request without duplication of the Identifier (API Id and OpCode).This is accomplished because Node C is able to query Node B for theaddress in memory of the initial Identifier so that an alternative(non-duplicated) Identifier may be selected. The alternative identifieris then used to create the Remote Byte Event by sending (see message 8in FIG. 27) a new message to Node B with the original memory address andthe alternative Identifier.

The following application packet represents a directed message from aclient to the software architecture 10 for getting remote variable datafrom an embedded variable map (Get Remote Variable Data). The messageinstructs the software architecture to publish information concerningthe data that exists in the embedded variable map. See FIG. 27 for anexample of use of this command. API ID Op Code Byte 3 Byte 4 Byte 5 Byten 2 14: getRemoteVarData API Id OpCode OpCode OpCode

The following application packet represents a directed message from thesoftware architecture 10 to a client for publishing remote variable data(Publish Remote Variable Data), and is a response to Get Remote VariableData. It reports data from the embedded variable map, such as the API,op code, size, and address. API ID Op Code Byte 3 Byte 4 Byte 5 Byte 6Byte 7 Byte 8 2 14: publishRemoteVarData Address Address Address SizeAPI Id OpCode Hi-Byte Mid-Byte Low-Byte

Core Discovery API: API ID=3 (Type 3, Version 1). Referring to FIG. 6,the following application packet represents a broadcast message from aclient to find nodes of the software architecture 10 (Find Node(s)).This broadcast message enables a node to locate other nodes of thesoftware architecture 10. API ID Op Code Byte 3-Byte F 3 1: findNodes

The following application packet represents a broadcast message (PublishNode) from the software architecture 10 allowing it to publish itspresence to other components participating on 14. This message is sentwhen a node of the software architecture 10 powers up or is re-set or issent as a response to Find Nodes. Additionally, this message can be sentwhen the node of the software architecture 10 through a secondaryDiscovery process adds (to itself) an API or adds Op Codes to anexisting API. Publish Node is not sent when a client dynamically adds anAPI or Op Code to the software architecture 10 (via DAQ Op 1, 2, 12,13). The payload of the feedback message contains a firewall password,which is to be used by the firewall security feature of the softwarearchitecture 10 (see FIG. 31 for an example of this feature). Thisallows the sender of the message to become a ‘trusted’ node on network14. API ID Op Code Byte 3 Byte 4 3 2: publishSANode Firewall FirewallPassword MSB Password LSB

The following application packet represents a message which can beeither directed or broadcasts from a client to the software architecture10 for getting API(s) (Get APIs) of the software architecture 10. Thisdirected message allows the client to discover the APIs that aresupported by a specific node of the software architecture 10. API Idmust be unique within an appliance. API ID Op Code Byte 3-Byte F 3 3:getAPIs

The following application packet represents a broadcast message from thesoftware architecture 10 to a client for publishing API(s) (PublishAPI(s)) of the software architecture 10. This message is a response toGet API(s) and is a directed message that allows the client to discoverthe APIs that are supported by the sending node of the softwarearchitecture 10. API ID Op Code Byte 3 Byte 4 Byte 5 Byte n Byte 7-ByteF 3 4: publishAPIs API # API # API # API n

The following application packet represents a message which can bedirected or broadcast from a client to the software architecture 10 forgetting API information (Get API Info). This directed message allows theclient to discover Version and Type information about the specifiedAPI(s). API ID Op Code Byte 3 Byte 4 Byte 5 Byte n Byte 7-Byte F 3 5:getAPIInfo API # API # API # API n (0xFF = all)

The following application packet represents a directed message from thesoftware architecture 10 to a client for publishing API information(Publish API Info) and is a response to Get API Info. This directedmessage allows the client to discover Version and Type information aboutthe specified API(s). There is one message per API, and the messages arebounded using the MMP flag of FIG. 4. API ID Op Code Byte 3 Byte 4 Byte5 Byte 6 Byte 7 Byte 8 Byte 9 Byte A Byte B-Byte F 3 6: publishAPIInfoAPI Id Type Type Version Version Number Descr Descr Descr MSB LSB MSBLSB Instances Char 1 Char 2 Char n

Bytes 4 and 5 represent an API's Type which can be used As an indicationof a specific sub-classification of an API. The value of Type can beused to determine compatibility concerns between sub-components (APIs).Byte 6 and 7 represent an API (of a particular Type)'s Version. Thisvalue can be used to indicate bug fixes or changes to functionality. Aswith Type, it enables a runtime compatibility check, which can informthe client if the versions are compatible. Alternatively, Bytes 4-7 canbe used in conjunction with Byte 3 to form a 5 byte class identifierwhere class refers to a class definition within a class library (whomone of typical competence with the state of the art would understand).Using the alternate approach, Byte 3 (API Id) is a runtime object handleand Bytes 3-7 numerically concatenated form the class id.

The Number Instances associated with Byte 8 signifies to the client thanan API has multiple instances. The client can follow up with GetInstance Info, which is described below, to find the Instance Ids thatbelong to the API. The Descr Char 1-Descr Char n is an optional featurethat can be helpful to developers. Descriptive text can be used toannotate API Id. For example, ‘upper’ or ‘lower’ could be used for thetwo cavities of a double oven.

The following application packet represents a directed message from aclient to the software architecture 10 for getting instance information(Get Instance Info). This directed message allows the client to discoverthe Instance Ids for the APIs that report more than one Instance of anAPI. The first instance of any API uses API Id as its Instance Id. Ifthere are multiple Instances of an API Id on the same addressable node,subsequent instances are assigned an Instance Id dynamically. Thesedynamically assigned Ids can be discovered by sending the Get InstanceInfo message. The value of the Instance Id should be used in place ofAPI Id when there are multiple instances of an API on a physical networknode. API ID Op Code Byte 3 Byte 4 Byte 5 Byte n Byte 7-Byte F 3 7:getInstanceInfo API # API # API # API n (0xFF = all)

The following application packet represents a broadcast message from thesoftware architecture 10 to a client for publishing instance information(Publish Instance Info) and is a response to Get Instance Info. Thisdirected message allows the client to discover the Instance Ids. Thefirst instance of any API uses API Id as its Instance Id. If there aremultiple Instances of an API Id on the same addressable node, subsequentinstances will be assigned an Instance Id dynamically. These dynamicallyassigned Ids are communicated via the Publish API Info message describedabove. For purposes of uniformity, Publish API Info is sent for thefirst instance (i.e., where API Id=Instance Id). There will be onemessage for Instance of API, which is bounded using the MMP flag. Thevalue of Instance Id should be used in place of API Id when there aremultiple instances of an API on a physical network node. API ID Op CodeByte 3 Byte 4 Byte 5 Byte 6 Byte 7 Byte 8 Byte 9 Byte A Byte n 8:publishInstanceInfo API Id Instance Id Type¹ Type Version² VersionDescr³ Descr Descr MSB LSB MSB LSB Char 1 Char 2 Char n¹Allows for APIs to be sub-classed or specialized. For example, API Idmay refer to a washing machine API and Type may specify a particularwasher model.²Enables version control (i.e. bug fixes or changes to functionality).Enables a runtime compatibility check, which can inform client if theversions are compatible.³Allows client to associate Instance Id with its physical function. Forexample, ‘upper’ or ‘lower’ could be used for the two cavities of adouble oven.

Preferably, the Descr Char 1-Descr Char n allows the client to associatean Instance Id with its physical function. For example, ‘upper’ or‘lower’ could be used for the two cavities of a double oven. However,the user of the software architecture 10 may use Descr Char 1-Descr Charn for any useful purpose.

Core Debug API: API ID=4 (Type 1, Version 1). The following applicationpacket represents a broadcast message from the software architecture 10to a client for publishing saturation (Publish Saturation). Saturationhappens when the supporting layers of the internal network 14 are unableto deliver the data that the software architecture 10 has put into theoutbound queue of WIDE 14A. The software architecture 10 has no queue;if the WIDE 14A cannot service the outbound data, then the softwarearchitecture 10 sends out Publish Saturation. API ID Op Code Byte 3-ByteF 4 1: publishSaturation

The following application packet represents a directed message from aclient to the software architecture 10 for setting a register forsaturation (Register for Saturation). The client sends this message to asoftware architecture node, which enables the Saturation message. Onlythe node that enables saturation can disable saturation. API ID Op CodeByte 3 Byte 4-Byte F 4 2: Saturation On or Off 1 = on 2 = off

Low Level API: API ID=5 (Type 1, Version 1). The following applicationpacket represents a broadcast message from the software architecture 10for publishing state (Publish State). This message sent as a result of achanged internal state of the machine, resulting from normal cycleprogressions, user interactions, Op Code 2 below, or other messagesreceived via network 14. API ID Op Code Byte 3 Byte 4-Byte F 5 1:publishState state enum

Exemplary machine state enumeration values are presented in thefollowing table. According to one embodiment of the invention, therunning state is included. However, in some cases, the running state issomewhat ambiguous and additional phase variables must be exposed sothat proper client side business logic can be written. In an alternativeembodiment, the running state is eliminated in favor of a more granularand definitive state machine where each phase of each state isdocumented properly. In this embodiment, sufficient address space existsin the byte for the additional enumerations. Machine State Enumerationidle 1 running 2 programming 3 fault 4 development 5 end of cycle 6pause 7 reserved 8 reserved 9 reserved 10 appliance specific 11-255

The following application packet represents a directed message from aclient to the software architecture 10 for toggling the householdappliance 12 software operating environment 16 governing 15 state ofFIG. 7 between Development and Idle State. Note Development State notshown on FIG. 7, but one with ordinary skill in the art can contemplatea Development state which can only be entered from Idle and when exitedgoes back to Idle. API ID Op Code Byte 3 Byte 4-Byte F 5 2:setDevelopmentState 1 = on 2 = off

Core Key Press API: API ID=6 (Type 1, Version 1). The followingapplication packet represents a directed message from a client to thesoftware architecture 10 for pressing a key (Key Press). This directedmessage allows the client to send virtual key presses. Key indexes arenot discoverable due to coding techniques used in the embeddedprocessor; therefore, key indexes may be extracted from the source codefiles manually or through other automated mechanisms. API ID Op CodeByte 3 Byte 4-Byte F 6 1: pressKey key index

The following application packet represents a broadcast message from thesoftware architecture 10 to a client for publishing key press (PublishKey Press). API ID Op Code Byte 3 Byte 4-Byte F 6 2: publishKeyPress keyindex

Exemplary key press index enumeration values are presented in thefollowing table. Key Press Index Enumeration start 1 cancel 2 pause 3reserved 4-25 appliance specific 26-255

Memory/Port API: API ID=7 (Type 3, Version 1). The following applicationpacket represents a directed message from a client to the softwarearchitecture 10 for writing memory (Write Memory). The Memory/Port portAPI is enabled via the Development State of FIG. 3 and the associatedinteraction is similar to the previously described association betweenDevelopment State of FIG. 3 and the Low Level API (API ID=7).

This directed message allows the client to write to a specified RAMlocation. The write to the specified RAM location is limited to a singlepacket. In the current embodiment, this would be 13 bytes shown in 28Aof 28. MMP (of 28)=1 is not valid for this message. API ID Op Code Byte3 Byte 4 Byte 5 Byte 6 Byte 7 Byte n 7 1: writeMemory Address AddressAddress data data data Hi-Byte Mid-Byte Low-Byte byte byte byte

The following application packet represents a directed message from aclient to the software architecture 10 for writing EE memory (Write EE).The write to a specified EE location is limited to a single packet. Inthe current embodiment, this would be 13 bytes shown in 28A of 28. MMP(of 28)=1 is not valid for this message. API ID Op Code Byte 3 Byte 4Byte 5 Byte 6 Byte 7 Byte n 7 2: writeEE Address Address Address datadata data Hi-Byte Mid-Byte Low-Byte byte byte byte

Poll Variable API: API ID=10 (Type 1, Version 1). Referring to FIG. 5,the following application packet represents a directed message from aclient to the software architecture 10 for reading poll variables (ReadPoll Variable(s)). This message instructs the software architecture 10to send a Publish Poll Variable message, which is shown below, forpoll-only variables. Poll variables can be hard-coded by a developer fora specific application and can be used if RAM/ROM resources do not allowthe use of the DAQ API. API ID Op Code Byte 3 Byte 4 Byte 5 Byte 6-ByteF 10 1: readPollVariable(s) Event Id 1 Event Event (0xFF = all) Id 2 Idn

The following application packet represents a directed message from thesoftware architecture 10 to a client for publishing poll variables(Publish Poll Variable) and is a response to Read Poll Variable(s).There is one message per poll variable index as specified in theinitiating Read Poll Variable message. API ID Op Code Byte 3 Byte 4 Byte5 Byte 6 Byte 7 Byte n Byte 9-Byte F 10 Event ID n: data data data data. . . data (publishPollVariable) MSB LSB

A note on the event operators discussed in the DAQ API section above.Byte 9 of the Create Event Numeric and Byte message (DAQ API opcodes 1&2) and Byte 5 of CreateNumRemoteEvent and CreateByteRemoteEvent (DAQAPI op codes 12 & 13) are the event change operator shown in theNVOEventStructure of FIG. 33. Operators are instructions which describeto the software architecture 10 the mathematical condition at which thesoftware architecture 10 should generate an event message. The tablebelow describes examples of event operators. The arguments for eventoperators are dependant on the type of event being created(numeric-based or byte-based which are op codes 1 and 2, respectively).

Event operators are part of the DAQ API which has two variations: basic(Type 1) and an extended (Type 2). Note the fifth column in the tablewhich denotes the availability of each Event Operator for the pluralityof revisions (4) of the DAQ API. Note that Types 1 & 2 are depreciatedand the preferred embodiments are the Basic Type 3 or the Extended Type4 which is inclusive of Type 3 functionality.

The following table denotes the event operators available when creatinga numeric-based event (API ID 2, Op Code 1 and 12): Operator DAQ API IdArg 1 Arg 2 Type Name (Byte 8) (Byte 9) (Byte A) Availability On Change0 — — 1, 2, 3, 4 Deadband 1 Deadband Deadband 2, 3, 4 Val (MSB) Val(LSB) Check Value == 2 Compare Compare 2, 3, 4 Val (MSB) Val (LSB)Boundary <= | => 3 Compare Compare 2, 3, 4 Val (MSB) Val (LSB) 25 msec 4— time = val * 1, 2, 3, 4 increments 25 ms Seconds 5 — time = val 1, 2,3, 4 (sec) Minutes 6 — time = val 1, 2, 3, 4 (min) Reserved 7 — — — BIND8 API Id: Event Id Unavailable DAQ = 2 at this time.

The following table denotes the event operators available when creatinga byte-based event (API ID 2, Op Code 2 and 13): Operator DAQ API Id Arg1 Arg 2 Type Name (Byte 8) (Byte 9) (Byte A) Availability On Change 0Offset 1, 2, 3, 4 (1 - size) Deadband 1 Offset Deadband 2, 3, 4 (1 -size) Val Check Value == 2 Offset Compare Val 2, 3, 4 (1 - size)Boundary < or > 3 Offset Compare Val 2, 3, 4 (1 - size) 25 msec 4 — time= val * 1, 2, 3, 4 increments 25 ms Seconds 5 — time = val 1, 2, 3, 4(sec) Minutes 6 — time = val 1, 2, 3, 4 (min) Bit Mask 7 offset mask 1,2, 3, 4 BIND 8 API Id: Event Id Unavailable DAQ = 2 at this time.

The BIND operator allows the client 16 to create multiple memory eventsfrom a single event trigger. In other words, once an Event ID has beenassigned, subsequent events can be created which will automatically besent when the original master event is triggered.

When a byte based event (op code=3) is set up with the On Changeoperator, a value of 255 in byte 9 will instruct the softwarearchitecture 10 to do a change detect for all bytes in the rangespecified by the address and size arguments.

The Bit Mask operator allows the ability to watch for bit transitionswithin a byte. The mask value should be set such that bit==1 is a ‘careabout’ and bit==0 is a ‘don't care’. When set to ‘don't care’ a valuetransition at that bit location will not result in an event generated.

The software architecture 10 does not provide an explicit solution fortime synchronization, but does provide an enabling mechanism. Thecapability of the remote client 16, 22 to create an event that isperiodically broadcast allows the remote client 16, 22 to maintain atime of day clock which is synchronized with the appliance. Since thesoftware architecture 10 may not explicitly expose a time of day clockAPI, the client 16, 22 can have the address in memory where time of dayis stored.

The software architecture 10 core has several design considerationswhich can be considered and contemplated to create alternativeembodiments of the invention described herein.

The following items can be considered when determining alternativeembodiments of the core implementation of the software architecture 10:

-   -   Message Architecture    -   Payload Structure or Message Size    -   Multi-Payload Message Integrity Checking    -   State Aware Messaging    -   API Versioning—Discovery    -   Connection Integrity    -   Traffic (flow) Control and Acknowledged Messages    -   Inbound Invalid    -   Inbound Valid    -   Outbound    -   Power-up Condition    -   State Integrity    -   Key Presses vs. Logical API    -   Multi-Node Network    -   Multiple Nodes    -   Multiple Clients    -   Multiple API implementations on same network    -   Multiple API implementations on the same network node    -   API(s) using same op codes—Namespace    -   SAP assignment    -   SAP discovery

Message Architecture

Message architecture is a primary design element whose solution has manydependent design consequences. The internal communication network 14protocol 28 provides new possibilities for event driven messagearchitecture as opposed to previous networks. An element to consider iswhether nodes will poll one another if they will register fornotification messages.

Polling is a practice of nodes periodically sending messages to theowners of data requesting updated values (e.g. continually request dataevery 100 ms). Polling is generally simpler to implement and morecommonly used, and can maintain connection integrity verified with eachrequest. However, when polling, the client must continuously ask forinformation. Network Bandwidth is used up with data that is not changing(bandwidth is the amount of data that can be passed along acommunications channel in a given period of time and there are severalfactors that effect bandwidth such as: number of nodes on a network, thetransmission frequency [baud rate], and the protocol overhead [CRCs,acknowledgements, source/destination IDs, etc], the transport protocolhardware, and cabling govern the limits of bandwidth, however, theApplication protocol has the responsibility to make the most efficientuse of the available bandwidth). Polling architectures do not scale: asnodes increase the number of messages increases exponentially. Assumingthere is information on each node that every other node needs:messages=nˆ2−n. Data is typically not synchronized with the memory ofthe control and message latency can be as much as twice the pollingrate.

Eventing is a practice of nodes registering with the owners of data tobe notified under certain conditions with new value of data. The dataowner is then responsible to send a message to the observing nodes whenthe data meets the criteria originally specified during registration.(e.g. send data only when data changes). In an eventing model, bandwidthusage is optimized because data is only sent when it changes. This modelscales well with message traffic and minimizes latency. Data issynchronized with the control. However, a connection validation(heartbeat) is needed. Otherwise, a client may not know when an eventsource is offline. Alternatively, connection validation in an eventingmodel can be achieved using acknowledgments which are an additionalmessage transmitted from the event observer back to the event source.When the event source transmits an event message, the event source willnot consider the transaction to be complete until an acknowledgementmessage is received. After a timeout has expired, the event source mayretransmit the event. This process may repeat for a configurable numberof acknowledged event transmission retries.

In Eventing architectures, Message binding of FIG. 9 and governed by MMPof 28 can be needed. It is a mechanism to group events which weregenerated from the same ‘scan’ of the microcontroller.

In this case, the preferred embodiment is an eventing model sinceeventing has advantages listed above as well as the simplicity of theremedies which address the disadvantages of eventing. Connectionvalidation is addressed by use of a heartbeat and/or acknowledgedevents. When the heartbeat is used, the event source will send out anevent periodically so that all of the event listeners of that node canknow that the event source is healthy. Likewise, implementing theheartbeat such that its frequency is programmable, can also be used tonotify all event subscribers that the event source is healthy. Theheartbeat period is configurable from the network. Acknowledged Eventswhich are described in detail herein are an alternate method which canbe used in addition to the heartbeat or programmable heartbeat to insureconnection integrity. Message binding is addressed with the messagebounding bit in the payload of each message packet 28. This allows thesoftware architecture 10 driver to collect messages corresponding to thesame microcontroller scan and present those to the application layer asa whole.

Using a the a sub-component of the invention known as the DAQ 30, thesoftware architecture allows a client 16 to dynamically register with anappliance control components 16 (enabled with the software architecture10 and including the optional sub-component of the software architectureDAQ 30) via the internal communication network 14 to receivenotification when the value at a specified memory location changesrelative to a specified condition. This relieves the appliance control16 from having hard-coded feedback variables and allows real-timefeedback to change according to the application, without client polling(event-based updates are accurately broadcast as needed).

A dynamic memory heap of FIG. 33, i.e., memory reserved for runtimeconfigurable feedback messages, is employed wherein the size of the heapis configurable at compile time. It has been found that each feedbackevent variable requires about 10 bytes of RAM. The events registered inthe heap (NVOEvent of FIG. 33) can be added or reset through internalcommunication network 14 commands issued by the client to a componentenabled by the software architecture having also installed the optionalsub-component DAQ 30.

Payload Structure 28A

One example payload structure is a static compound payload whichconsists of grouping multiple variables together (at design time) sothat the client can, with one transaction, send a complete command to,or receive the complete state of a component within the appliance 12. Inthe case of a command, the client may not intend to change everyvariable in a payload, therefore, a pre-requisite status update isrequired to populate the command payload with the current status forthose variables which are not intended to change. Moreover, thevariables that change may not map directly into a single payloaddefinition resulting in multiple messages containing interspersedchanged and non-changed data.

In a simple payload structure, only one variable can exist in a payload.This has a simpler, easier implementation and can approximate a dynamiccompound payload (described below). However, bandwidth is not optimizedbecause of a larger ratio of message overhead to data and messagebinding needed as variables are sent separately.

In a dynamic compound payload structure, payloads are not staticallydefined at design time, but are dynamically created by the sending node.In this case, the length of the payload is determined by the data, whichthe sender wishes to send, and moreover, there must include identifiersand possibly delimiters in the payload, which will allow the receivingparser to un-marshal the component parts of the payload. To reiterate,the receiving node must have a parser sophisticated enough to separatedthe multi-variable payloads into their component parts. This payloadstructure optimizes bandwidth but can increase ROM requirement due tothe sophistication required by the parser. There is also some addedoverhead to the application protocol since the dynamic compound payloadmust embed op code lengths as part of messages, requires additionalparsing by the receiving component and can be hard to understand andimplement.

It is a preferred embodiment of this invention to employ a simplepayload structure for the application protocol. The complexity of adynamic compound payload can have difficulties in a cost-benefitanalysis for the messages employed in the software architecture 10. Tomaximize the use of the software architecture 10, the complexity of theinterface should be preferably minimized. By way of using compoundpayloads, by their complex nature, would potentially retard the use ofthe software architecture 10, especially with embedded clients. Simplepayloads are a good approximation of dynamic compound payloads eventhough there can be additional message overhead (i.e., there are fivebytes of overhead for every the internal communication network 14message). There is an additional two bytes of overhead to support thesoftware architecture 10 application protocol 28. This leaves 13 bytesper the internal communication network 14 message protocol 24 for datain some application-specific conditions. Using a static compound payloadcan be inflexible and wasteful.

Message binding of FIG. 9 is addressed with the use of the MMP bit inthe payload of each message packet. This allows the softwarearchitecture 10 driver to collect the messages corresponding to the samemicrocontroller scan and present those to the application layer as awhole.

State Aware Commands

Relative to a user interface for an appliance 12, the appliance 12 actslike a state machine. As keys are pressed, the state machine transitionsfrom one state to another. For each state, it is known what keys arevalid candidates for the next push. Likewise it is also know which keysare not valid for the next push.

Generally, when a key is pressed that is invalid, the appliance 12 willproduce an audible alarm to indicate to the user that the Appliance wasin an inappropriate state for that key. The same concept exists for theexternal client wishing to send valid commands, albeit that this clientmay not sending key presses.

In general, two types of state machines are developed for an appliancecontrol: the key press state machine (as mentioned above) and a processstate machine. An example of a typical process state machine is shown inFIG. 7.

FIG. 7 is a schematic illustration illustrating various states of ahousehold appliance 12, such as a washer shown by example in FIG. 7, andto the interaction of the software architecture 10 through variousstates 32 and a fault error mode 34. The various states 32 of theexample washer appliance are shown in FIG. 7 as idle, washing, rinsing,spinning, and pause. Other states for this example appliance 12 as wellas states for different appliances 12 are contemplated and the exampleshown in FIG. 7 should be by example only.

The states of the process state machine can be reported to the externalclient 16. However, upon inspection, it can be seen that the processstate machine in FIG. 7 does not address events from all possible userinputs (i.e. clock set, spin speed selection, load size option, etc). Ingeneral, the logic in the appliance control has a final else clausewhich handles all other cases which were not pre-defined.

Supposing that it is desirable for the client 16 to understand the rulesgoverning the state transitions of the control so that it may avoidsending invalid commands. Accounting for the fact that the client 16will not be sending key presses, the designer must understand that thereis no available document or data structure allowing client sidevalidation (i.e., validation before the request is sent). Eventually,this can lead to client applications that are likely to send a commandthat the receiving component will not execute due to its validationlogic which is based on the exemplary state of FIG. 7.

The solution can have an effect not only on bandwidth usage, but also tothe overall robustness and end user satisfaction of the application.From a bandwidth perspective, it can be stated that a message notresulting in the desired action, but rather, an error code or retry is awaste of bandwidth (assuming that it could be prevented). From a usersatisfaction perspective, applications which prevent the user frommaking mistakes are generally considered more “user friendly” than thosewhich allow the user to make mistakes and then use dialog boxes toexplain what happened.

Various embodiments of state appropriate commands have been contemplatedin accordance with this invention.

Using a client-coded rules section, a subset of state information isused to develop case logic or an emulation of the state of the controlfor the purpose of preventing invalid requests. This model typicallydoes not impose change on the control architecture but can have theclient and control can easily be out of sync. The rules and logicdevelopment can be based on trial and error (e.g., code, test, re-code).A client design will rapidly evolve, creating poorly designed proceduralcode.

Using a design-time state-based API data model, a data model isdeveloped such that the client can interpret it and prevent invalidrequests. In essence, it is a correlation between state and valid opcodes (op codes are message identifiers). The advantage to this is thatthe developer of the Op Code or API is also responsible to publishinformation to the client developer (at design time) allowing thedesigner to emulate the state machine on the client. This emulated statemachine enables the client application from sending invalid requests. Itis necessary for the control to expose each state defined in the APIdata model. The design-time data model requires the control developer tobe responsible to communicate state rules governing Op Code usage. Theclient and control can easily get out of sync because data is notavailable at runtime. A document must be created which reflects the aswritten code. This document must be maintained and published. Thedocument must be parsed or converted into client side logic and thisdoes not work all of the time. The appliance state can change just as acommand is being sent resulting in an invalid command.

Using a run-time state-based API data model, this solution is identicalto the previous with the exception that the data model is not sharedbetween developers at design time, but between client and control atruntime. Some additional messaging is required for this data to becommunicated from the control. In the runtime data model, the controldeveloper must be responsible to communicate state rules governing OpCode usage. A client can discover at runtime the Op Code/Statecorrelation definition. The client and control are always in sync andthe client and developer activities are optimized—no manual translationto/from a document. Additional code (ROM) (written once) required tomarshal and un-marshal Op Code/State correlation definition. Somenetwork bandwidth required for transmission of data and some start-uplatency as a result of transmission of data. This does not work all ofthe time. State can change just as a command is being sent resulting inan invalid command.

Using a post-command acknowledgment enumeration model, the three optionsabove have the goal of preventing the command from being issued byclient to control in the invalid state. This solution does not attemptthis preemption. Instead, this technique allows the client applicationto send any command at any time. If the command is invalid, anacknowledgment will occur so that the client can take appropriateaction. This acknowledgment may or may not include an enumerated reasoncode. In a post-command reason code model, there is no change imposed onthe control architecture but a client is more likely to send commandswhich will be rejected. The client developer must design a strategy tohandle rejection acknowledgment and the end-user experience may not beas pleasant due to frequency of rejected command messages.

Using a design-time naming convention and source code parsing modelwhich is a combination of the design and runtime data models, this hasthe least impact on the structure of the embedded code, as well,delivers the desired runtime functionality. It is accomplished bycreating a client-side parser which can parse the embedded source codeand determine the variable to be monitored for each external Op Code.The requirements for this solution are: (1) each non-diagnostic externalcommand (Op Code) will have an associated single Boolean variable whichrepresents the permission state required for execution; and (2) a namingconvention is used such that a parser can associate each permissionvariable to the corresponding external Op Code. In a source code parsingmodel, the control developer is responsible to communicate state rulesgoverning Op Code usage. A client 16 can discover at runtime the OpCode/State correlation definition pending proper versioning and theclient and control are always in sync with proper versioning. The extrareference document is not needed, however, there are non-trivial changesto coding practice, additional logic to be executed each scan, smalladditional RAM and ROM required, and only sophisticated clients are ableto parse source code.

Using a learning client model, this solution requires no change to theembedded system. In this case, the client would “learn” after eachrejected command and build a client side permission map that could, overtime, achieve the desired runtime behavior. In a learning client model,there is no change imposed on the control architecture, however, thisassumes that the correct state variables are being evaluated at the timeof rejection. If no state variables are being observed, then the clientcannot learn what caused the rejection.

It has been found that several of these options are preferredembodiments. For now, a main preferred embodiment is the runtime APIdata model. An exemplary beneficiary of this design would be the homecontrol application. The model, however, requires additional embeddeddesign. And because the current business environment does not create arequirement for this embodiment, the post-command acknowledgment isadopted until such time that the cost-benefit of adopting the runtimeAPI data model (also referenced as Taxonomy Engine) becomes favorable.

One of the challenges of the software architecture 10 is to providefunctionality without impacting the production schedule of the appliance12. The software architecture 10 can implement an acknowledged requestmodel. NVORecipeStatus (API ID=1, Op Code=1) is a preferredacknowledgment message that the software architecture 10 sends aftereach message received.

API Versioning—Discovery of FIG. 6

Although the core of the software architecture 10 is independent of anyAPI, its purpose for the software architecture 10 is to expose multipleAPIs. It is realistic to expect that APIs will be continually added tothe software architecture 10 over time. In anticipation of this,consideration for API discovery and versioning is made.

It is also conceivable that as the software architecture 10 applicationsgrow, the microprocessor resources will not be sufficient to support allthe software architecture 10 APIs and functions simultaneously. With theuse of compiler directives, the software architecture 10 can beconfigured so that APIs will appear and reappear for the same model overthe development life of the machine.

Discovery is a key to the long-range success of the softwarearchitecture 10. A fundamental purpose of the software architecture 10is to act as middle-ware between client 16 and control component 16.Given the scenario described below, it will be necessary for clients 16to query the control to discover what the current capabilities are. Ifcertain capabilities are not present (i.e., compile time decision), itis desirable for the application to be able to gracefully fail andcommunicate to the user that the support for the application is notcurrently compiled into the appliance control software.

There can be dozens of client implementations and dozens ofcross-platform and platform specific APIs. Compiler directives can bedeveloped to include or exclude certain functions of the softwarearchitecture 10. There may not be space on the control for all possiblefunctions of the software architecture 10 to exist on the microprocessorsimultaneously.

Various embodiments of the invention described herein relating to theversioning and discovery methods of APIs are contemplated withoutdeparting from the scope of this invention.

Using a model number-based discovery model, the client is responsible tounderstand the capabilities of the control. This can be done usingclient-based data structures, remote data bases, or runtime codedelivery vehicles like OSGi which include all relevant information on aparticular model number for an appliance 12. In a model number-baseddiscovery model, there is no additional requirement on the appliancecontrol. However, a model number is not typically assigned at beginningof a product development cycle so it is not available in early softwaredevelopment. Model numbers can be changed due to color schemes,branding, and other irrelevant factors. Different APIs can be residentson the same model due to compiler directives. The client can be requiredto be responsible to acquire capabilities definition or equivalent codeafter discovery.

Using an API ID-based discovery model, API-based discovery does not relyat all on model number, but rather defines any product as a collectionof well-defined interfaces. This technique allows for the same APIs tobe resident on multiple products resulting in some reuse. In an APIID-based discovery model, the reference to API ID compensates for theshortcomings of a model number-based approach. This model allowsmultiple products to share same compiler directives and same APIdefinitions and can promotes sub-function reuse of the softwarearchitecture 10. However, the client can be responsible to acquirecapabilities definition or equivalent code after discovery, additionalmanagement overhead can be required to maintain and assign unique APIs,and additional resources from a control microprocessor can be requiredto support discovery Op Codes (i.e., additional messaging).

Using a capabilities discovery model (also referenced as a TaxonomyEngine), this model takes API Discovery an additional step. In additionto the ID of an API, the client will also request and obtain the datadefinition corresponding to that API. In other words, the client willdiscover each function call, each function calls arguments, and all thevalid values for each argument. In the capabilities discovery model, nosecondary lookup is required to acquire capability definition. Thismodel approaches a UPnP or Web Service type concept and sets thefoundation for the conversion to LCD screen user interfaces which can bedata driven. However, this concept may be cost deficient when applied tolow margin mechanical key pads and actuators. And, to take advantage ofthis technique, the client 16 must develop an interpreter for thecapabilities definition which can require more intensive modeling effortby the software architecture 10 sub-function developer and significantlymore resources from the control microprocessor.

It has been found that, at the time this application was prepared, anAPI ID-based discovery model is a preferred embodiment. In addition toAPI ID, each API can have a type and a version, so that many differentpermutations of an API can exist over time. This can make the protocolmuch more flexible (e.g. there can be many types of APIs for aparticular appliance 12, such as a dryer, as well as a different versionof each type: Dryer API, Horizon Dryer Type, Version 1).

Discovery can be initiated in a number of ways according to theinvention. On power up, each node enabled with the software architecture10 broadcasts a message on the internal communication network 14 calledPublish Node.

Secondly, a node, at any time, can broadcast a message on the internalcommunication network 14 called Find Nodes. This message will result inall nodes responding with a Publish Node message. This API is discussedin more detail with respect to FIG. 5 and the Discovery API.

As discovery is a key to the software architecture 10, versioning is akey to successful discovery. The same rationale used to justify APIdiscovery can be applied to API versioning. Versioning allows the clientto find out more information about the API which it has discovered.

During API discovery, the API version and type is reported within thesame data structure as the API ID. For example, a simple number bumpingapproach can be employed. Further, a one- or two-byte or n byte datastructure for API ID and a version number are contemplated.

Connection Integrity

In eventing architectures, connection integrity is an issue; whereas inpolling architectures, connection integrity is inherent. In eventingarchitecture, the client 16 can successfully register to listen forfeedback (such as for a temperature reading). Once registration iscomplete, the client relies on the control for notification of changesto temperature. As such, the client would interpret a network problem asa constant temperature. By contrast, in a polling architecture, theclient would constantly ask the control for temperature feedback theresponse or lack thereof would immediately indicate the integrity of theconnection.

Using an optional heartbeat model to perform connection integrity, aclient must register for a network-based heartbeat. Using an automaticheartbeat model, the software architecture 10 produces a heartbeatautomatically when a notification registration buffer is not null.Heartbeats can be broadcast messages or messages directed at a specificnode.

In an optional heartbeat model, if there is an instance when it is notneeded, the heartbeat can be eliminated. In instances where it isneeded, a client must configure the software architecture 10 to producea heartbeat. In an automatic heartbeat model, there is no effortrequired for desired functionality—the software architecture 10 isinherently robust. In a broadcast heartbeat, fewer messages need to besent, a custom heartbeat can be accomplished through time-based eventupdates and it has simpler implementation. However, this can result inmessage handling from other network nodes which are not participating inthe software architecture 10 collaboration. Also, nodes not properlyhandling broadcast messages can misinterpret incoming messages. In adirected heartbeat model, only enabled nodes need to handle the softwarearchitecture 10 application protocol. However, more messages can be sentusing a directed heartbeat model.

For this invention, it has been found that a preferred embodiment is aheartbeat for connection integrity, and specifically, a broadcastmessages can be used for a heartbeat. Clients that do not prefer thebroadcast heartbeat rate can alternately use a periodic time-based NVOevent update instead. Making the heartbeat automatic can lessen theburden on the client. With respect to the APIs contained in the softwarearchitecture 10, the following functions are supported as part of theCore API (Id=1): Heartbeat Message, Set Heartbeat Period. The heartbeatis preferably automatically initiated with a default period upon receiptof the first message from a client 16.

An additional optional preferable method for connection integrity can beintroduced into the software architecture 10. It has been found that asthe application of the software architecture proliferated, it wasdetermined that an additional method of connection integrity was needed.Using the heartbeat method for connection integrity is appropriate formany application scenarios. This method is chosen because it representsa good tradeoff between utilization of bandwidth and confidence level ofthe event source. However, it is possible that an event message sent bythe software architecture 10 will fail to be processed by the intendedevent subscriber even when the event subscriber did not detect a missingheartbeat. In this case, the event subscriber cannot detect failure andtherefore cannot take corrective action. The corrective action, in thecase of a detected missing heartbeat, is that the event subscriber mayrequest that the event source re-send (all or a sub-set of all) eventsso that the event subscriber has the most current data. To address thispotential undetected failure mode, a second method of connectionintegrity has been made available through the software architecture 10.The method, known as acknowledged events, allows the integrity of eachevent message to be individually managed. FIG. 29 illustrates thefunctionality of the acknowledged event. Further details concerningacknowledged events are described in the descriptions of FIG. 29.

Traffic (Flow) Control

Configurable asynchronous processes are powerful, but can fail whenconfigured beyond their physical processing and bandwidth limits.Mechanisms are introduced to prevent saturation in four known failurescenarios: inbound invalid requests, inbound valid requests, outboundmessage events, and a power-up condition.

Inbound Invalid Requests. It is likely that the client will format andsend a request that cannot be properly parsed or understood by thecontrol or may be invalid per the state of the control.

Inbound Valid Requests. Without consideration, the client may ask thecontrol to do a second task before the control has been able to processthe first.

In a buffering model, a receive buffer could be used allowing the clientto send many requests without concern for the control's ability toservice them. In this model, the client has no responsibility eventhough the implementation of this model is simpler. However, bufferingdoes not solve the flow control problem; it only delays or makes theproblem less likely or less frequent and buffering requires more RAM.

In a flow control model, messaging can be used so that the client isrequired to wait until a control is ‘ready’ before sending a secondrequest. In a flow control model, the flow control problem is solvedrobustly, and failure modes are eliminated. However, a client mustimplement a flow control protocol.

In an acknowledged request model, a control provides a response eitherpositive or negative to each client request. In an acknowledged requestmodel, this model allows a client 16 to develop simple re-try orrecovery scenarios. However, this model requires more bandwidth for theacknowledgments and additional ROM and design is required.

In an unacknowledged request model, client requests areun-acknowledged—a client must use state information to determine if thecommand succeeded. In the unacknowledged request model, less bandwidthand ROM is employed. However, application user experience can suffer, aclient application has no indication if an issued command was successfuland therefore cannot automate retries, and a user will notice anunsuccessful command and need to manually replicate the command actions.

It has been determined that a preferred embodiment of this invention isa flow control protocol with an acknowledged command model. Moreover,acknowledgments can be enumerated such that a client process can developthe most robust recovery scenarios as possible. Because theacknowledgement message previously mentioned in this invention providesthe API and op code for the acknowledged command, a client can discernthe command being responded to. This prevents confusion in a multiplecontrol board network, in which multiple control boards inside of anappliance all utilize the software architecture 10. Flow control andcommand acknowledgment are techniques which allow the client to senddata as rapidly as possible without saturating the control. The benefitscan be very responsive applications without introducing unnecessarylatency or unexpected application failures.

The flow control benefits are achieved using publish Acknowledgement,API Id=1, Op Code 1. Each command is acknowledged with a publishAcknowledgment response. A new command is only allowed after receipt ofa a publish Acknowledgment value of READY or UNSUPPORTED. publishAcknowledgment has the state machine for command flow control as shownin FIG. 8.

FIG. 8 is a schematic illustration showing how the architecture 10 ofFIG. 1 interacts with incoming commands according to the invention andvalidates or rejects those commands based upon the state of thehousehold appliance. Various flow control status indicators are shown inFIG. 8 with reference numeral 36 as, e.g., POWER UP, READY, BUSY,REJECTED, and UN_SUPPORTED based upon various commands 38 and issuedresponses 40.

Outbound Messages Events (Feedbacks). During each scan of themicrocontroller, the DAQ 30 of software architecture 10 collects bytearrays representing the events that must be sent out on the bus (seePROCESS DAQ EVENTS state of FIG. 36. The DAQ 30 of software architecture10 is configurable as shown in FIG. 5 and therefore it is possible thatthe client or clients could configure the software architecture 10 totransmit more data than is possible for the bandwidth of thecommunication bus (i.e., over configuration).

In order to prevent this, a configuration limit model can be employedwhich would limit the ability of clients 16 to configure the softwarearchitecture 10 to avoid this problem. In a buffering model, thesoftware architecture 10 can be equipped with a transmit buffer. In asaturation message model, the software architecture 10 detects whenthere is too much data presented to the transport layer such that thedata may not be sent to the client. In a require re-initiation model,event distribution is suspended and an event saturation message is sendout and/or broadcasted. Eventing is resumed once a SendEvents (e.g.,255=ALL) message is received. In a no re-initiation model, a saturationmessage is sent out and/or broadcasted and then the softwarearchitecture 10 continues eventing.

In the transmit buffer model, the client has no responsibility andclient implementation is simpler. However, buffering does not solveproblem; it only delays or make problem less likely or less frequent andrequires more RAM.

In the configuration limit model, this model would prevent problem sothat a recovery process is not necessary, it is impossible to derive aconfiguration limit, and the limit is based on machine state transitionswhich are of a random nature relative to the software architecture 10.

In the saturation message model, the client can detect that the softwarearchitecture 10 was unable to submit new data to the internalcommunication network 14 on at least one scan. The client is unable todetermine if data was missed and the saturation message does notnecessarily mean there was failure—only the possibility of missed data.

In the no re-initiation model, the client has no responsibility,however, the client developer is not forced to implement saturationrecovery process, the client developer can not be aware that events canbe dropped due to over configuration of the software architecture 10.This type of failure is not catastrophic and therefore clientapplications may be oblivious to the loss of data.

In the require re-initiation model, the client developer must considerthe saturation failure and its implication to the application, thisprevents transient hard to find bugs, and the failure modes arecatastrophic and/or obvious. However, the client must implement asaturation recovery process and there may be momentary latency during arequired re-initiation process.

In a do nothing model, unnecessary work is avoided but an unforeseensituation may arise causing client developer to spend timetroubleshooting something which can be diagnosed programmatically.

It has been determined that a saturation message that does not requirere-initiation to be available via compiler directive is a preferredembodiment of this invention. The saturation message must besuccessfully transmitted before further events are put into thetransport layer transmit buffer. The following messaging functions aresupported as part of the software architecture 10 Debug API (API Id=4):get Saturated and Register for Saturation Message.

As shown in FIG. 4 packet structure 28, all packets of the softwarearchitecture 10 use a Cmd/Fb flag enabling the possibility of namespaceconflict. Thus, it is possible to overlap op codes under the same APIusing the Cmd/Fb flag for discernment.

Power-Up Condition. If the software architecture 10 node experiences atransient loss of power or micro reset, it might be possible for theclient to have an incorrect snapshot for the software architecture 10modules variables. For robust operation, the software architecture 10can notify its client that the previously exported variables can nolonger be considered valid. When considering the transient condition,the configuration of the software architecture 10 could potentially bestored in non-volatile memory, which would allow for the automaticresumption of communication.

In a broadcast message model, the software architecture 10 can send aspecial broadcast message notifying all clients to ‘dump their cache’upon power-up. It is understood that some applications of client 16 maynot need to consider this failure mode and therefore would not make useof the special message. It is also known that the softwarearchitecture's software operating environment could experience a failure(resulting in a reset of its internal memory) and a recovery within theheartbeat period. With only the heartbeat as a means of detection, thisfast recovery would obfuscate the probability that the client's 16memory holding copies of certain values from the memory of the softwareoperating environment of the software architecture would no longercorrespond to the current values within the memory of the softwareoperating environment. To address this failure scenario, a power-upmessage can be included in the software architecture 10. This message isindependent of the heartbeat and would indicate to any client 16 thatany previously held values of the memory of the software operatingenvironment of the software architecture 10 would be most probably beinvalid and that the client should, through the use of the sendEventmessage of API 1 Op Code 7, re-acquire the current values. It is alsounderstood that the client should suspend or modify any logic orcalculations which operate on these memory values in an appropriate wayuntil the current values are re-acquired.

In a loss of heartbeat model, the software architecture 10 candiscontinue its heartbeat, allowing the client to determine the properfailure mode action. However, as described above, loss of heartbeatmodel does not cover all failure scenarios. This is especially true whenusing the automatic resumption model.

In an automatic resumption model, the software architecture 10 canautomatically resume normal operation from the last known state after apower-up or reset. In the automatic resumption model, the client maymisinterpret the information received as state transitions that did notoccur. In other words, for some State A existing before a Reset orPower-up and some State B which is the initial power up State; withoutadditional indication of a State I representing power-up or reset, theclient may interpret a State A to State B transition as occurringwithout having passed through State I.

In a require re-initiation model, a client developer must consider thescenario of the preceding paragraph and its implication to theapplication. This can prevent transient, hard to find bugs, because thefailure is catastrophic and as such easily identified and fixed.However, the client must implement transient recovery process and therecan be a momentary latency during re-subscription/data re-acquisitionprocess.

It has been determined that a loss of heartbeat model requiringre-subscription after a power-up/reset is a preferred embodiment of thisinvention. The advantage of a special broadcast message indicative ofthe state of initial conditions is also understood to be a usefulindication when the resources within the software operating environmentallow for such additional feature. Even though the heartbeat mechanismcan be made to approximate the utility of a power-up message mechanismby making the heartbeat time out small, a preferred solution willinclude a powerup message when resource constraints of the softwareoperating system are not prohibitive. For this reason, the softwarearchitecture 10, supports as an optional feature, a power up messagewhich is API Id=3, Op Code=2, publishSANode. Re-subscription can berequired because the dynamic event triggers are stored in RAM and willbe lost on a power up.

Preferably, the software architecture 10 module does not send anymessages out until it has detected a client except the optional power upmessage publishSANode. A client is detected by the receipt of a validcommand. Once the client is detected, a configurable heartbeat messagebegins broadcasting and the software architecture 10 is then ready fornormal operation. Therefore, if the host microprocessor for the softwarearchitecture 10 experiences a power-up/RESET, the client will benotified by sensing the absence of the Heartbeat message (see API Id=1Op Code=2) and optionally sensing the message, publishSANode (see APIId=3 and Op Code=2).

State Integrity

The DAQ 30 of FIG. 5 of the software architecture 10 provides severaldistinct advantages over a commercially available DAQ systems. Thesoftware architecture 10 can expose any variable in the microprocessormemory. In general this will also include the I/O signals of interest.Prior art DAQs cannot do that. The software architecture 10 is availableto production machines via a single 3-wire plug, whereas prior art DAQsor emulators require more wiring or harnessing. Prior art DAQs are notpractical in the context of a consumer field test. The softwarearchitecture 10 can be deployed on the production system. The softwarearchitecture 10 coupled with a modem can provide remote monitoring.

The most fundamental aspect, making the software architecture 10different from prior art devices is that it runs as a blockingsubroutine (SA_ProcessOutgoingEvents of FIG. 36 and FIG. 11) calledsynchronously from the main( ) function of the microprocessor. Thisinsures that the client can have (within the limits of networkbandwidth) a complete scan-by-scan snapshot of microprocessor memoryexactly as the execution engine of the microprocessor scanned it. Thisopens up many interesting possibilities ranging from low-cost emulationand debugging to hybrid algorithm development using the softwarearchitecture 10 to enable PC-aided co-processing with the productionelectronics.

A comparison of asynchronous data collection and synchronous datacollection methods will now be described. In asynchronous collection:

-   -   1. Let A and B be variables inside the appliance control memory.    -   2. Let C be a variable calculated in the client as the product        of A and B.    -   3. Let A=23 and B=67.    -   4. Client polls for A: A=23.    -   5. A and B change. A=56, B=77.    -   6. Client polls for B: B=77.    -   7. Client calculates C: C=A*B=23*77 (this combination of A and B        never occurred on the microprocessor).    -   8. Client presents invalid value for C to the consumer or end        user of the application.

Most applications will work with asynchronous data collection It issimple and straight forward. However, problems associated withasynchronous collection are extremely time-consuming to debug andidentify.

In synchronous collection, the client defines or registers A and B withthe software architecture 10. This allows the software architecture 10to maintain coordinated values of A and B on every scan.

-   -   1. Client registers for A and B    -   2. Client requests a send all.    -   3. Current values for A and B are sent by the control to client.    -   4. A and B change. A=56, B=77    -   5. Control sends bounded event(s) containing A=56 and B=77    -   6. Client does not calculate C until the bounding or end        delimiter bit is reached.    -   7. Client calculates C=56*77    -   8. Client presents correct value of C.

With synchronous data collection, the data collection is robust andvirtually bulletproof. It enables applications which have not yet beenconceptualized and allows for ‘real time’ debugging of productionsoftware w/o special coding on the production electronics. However,additional RAM is required on the control to maintain snapshots ofclient “care about” variable or property list.

It has been determined that the software architecture 10 preferably cansupport and promote the synchronous data collection technique. However,asynchronous memory polling is available in the Core API (API ID=1).

With the synchronous data collection technique being employed, theconcept of bounded updates should be discussed. Bounded updates areevents that are grouped together as a snapshot of the appliance statetaken during the same scan of the host microprocessor's Main( ) loopexecution. The appliance control main loop will allow for an iterativeupdate of feedback variables that are registered with the DAQ API (e.g.,every 25 ms). Each registered variable is monitored and only those thatchange value according to their memory monitor change operator arebroadcast as updates to the client. When updates are in the process ofbeing broadcast, no new updates are allowed in order to preserve thesnapshot in time. A snapshot is communicated to the client using the MMPflag in Byte 2 of the software architecture 10 header as shown in theapplication protocol 28 in FIG. 4.

While the MMP of 28 FIG. 4 is true, more messages are pending for thesnapshot. When MMP is false, the current message is the last message inthe snapshot. Therefore, if the first message of a snapshot is the onlymessage in that snapshot, MMP will be false.

The example in FIG. 9 illustrates a bounded command(Cycle+Temperature+MMP) with acknowledgements, followed by twoconsecutive bounded updates. Where bounded refers to elements ofprotocol which indicate to the receiver that more messages are comingfrom the source and that data processing by the application logic of thereceiving component should be delayed until the bounding indicators ofthe protocol within the packet structure 28 (MMP bit 7) indicate acomplete transaction at which time data processing by the applicationlogic is permitted. The bounded command is shown by reference numeral 42and the two consecutive bounded updates are shown by reference numbers44 and 46, respectively. Notice that updates do not begin until boundedcommand execution is complete, providing the client the ability tofilter away transient feedback data. Bounded commands are provided bythe same mechanism, MMP found in 28, as bounded updates in order toprovide applications a greater level of control.

The example of FIG. 9 is conceptual. The actual mechanism is MMP foundin 28. However for illustrative purpose, the bounded command begins withan initial “begin” command initiator (MMP set) and includes commands toset a washer cycle to wash, a recipe status to ready, a watertemperature to medium, again a recipe status to ready, and finally acycle start indicator, followed by a command terminator (MMP unset). Itcan be noted that, in FIG. 9, updates (such as by eventing) are disabledto prevent updates from happening before the bounded command iscomplete. In addition, a “process command” indicator is shownperiodically throughout the bounded command processing in the appliance12 to illustrate the portions of the command issued from the client 16through the internal communications network 14 are processed.

In the bounded updates 44, the updates are once again enabled (sincethey were disabled at the beginning of the bounded command 42) to allowthe appliance 12 to report its status to the client 16. In the exampleshown in bounded updates 44, the acknowledgment state is shown to ready,the cycle is reported as wash, the state is reported as running, thebasket is reported as fill, the pump is reported as on, and thetemperature is reported as medium. Again, beginning and terminatingindicators enclose the bounded update 44. These beginning andterminating indicators can be reported by use of the flag, MMP, in theapplication packet structure 28 as discussed in FIG. 4 or another methodwhich would be apparent to one skilled in the art of network protocol.

In the bounded update 46, the basket is reported as agitate, the pump isreported as off and the motor is reported as on. Again, beginning andterminating indicators (MMP) enclose the bounded update 46.

API Strategy (Key Presses vs. Logical API)

In almost all cases, the appliance 12 is controlled by an integratedkeypad. The embedded software handles the key presses or user eventsgenerated by the keypad and action is taken. In effect, the key presshandling function(s) are the API for the appliances. The question to beconsidered in this section is if this API is the best approach or if asecond API should be developed for an external client 16, 22.

In a key presses model, to use the Key Press API, the external client 22must create virtual key presses and transmit those over the network. Theexternal client 22 must be designed with the knowledge of the integratedkeypad so that these key presses can be generated correctly and thisrequires an external network interface card to generate key presses. Inthis model, no modification is needed to underlying keypad programming.However, the client 22 must monitor the current keypad state in order todetermine the key presses needed to achieve desired state. The ClientAPI must change if the design of the key pad changes rather than machinecapabilities. This architecture breaks best practices of softwaredevelopment by interposing a presentation tier between a middle tier andthe persistence tier. There will need to be extended commands for EnergyManagement, Service and Diag., Testing, etc which are not available inthe basic keypad interface. There must be a way to have a logical API aswell as leverage as much as possible the validation code associated withthe key press handling routines without needing to duplicate code.

In a logical API model, by contrast, the Logical API is developed froman abstraction of the machines capabilities rather than the design ofthe keypad. For example, Bake on a European oven using key presses mightrequire that the client read the encoder position of the cycle dial andprogrammatically change the encoder to correspond to a Bake setting. Ifusing a logical API, the client need only send the Op Code for set Cyclewith the enumeration value for Bake: {0x01, 0x01} (setCycle(Bake)). Inthe logical API model, the client 16 need not be concerned with thekeypad state, keypad design, or key press handling routines. The APIremains independent of changes to the keypad design, allows for extendedcommands, and is an industry best practice.

It has been determined that the software architecture 10 will use alogical API which is integrated with the key press handling routines.The logical API exposes many of the extended commands, which enablevarious value-added applications. In the appliance control, when a keyon the user interface is pressed or an external command is issued, it isdirectly mapped to a Logical API function call as a common entry point(e.g., when the WASH key is pressed or an external WASH network commandis issued will both call the SetCycle(WASH) function in a washer withthe software architecture 10 installed thereon). A Logical API functionaims to describe a set of functionality in a parameterized manner sothat it can be re-used. For example, non-logical specialized functionsfor temperature might be IncrementTemp( ) or DecrementTemp( ), whichcannot easily be used to set the temp to any value. But a logical APIfunction can be: SetTemperature(newTemp, or temp++, or temp−−). Thislast function can be used by both key presses and external commands.

A command handler for the software architecture 10 can comprise a methodfor the embedded software to response to either logic commands (e.g.,setCycle(bake)) or key presses (e.g., pressing the “Bake” button on anoven appliance 12). The method translates incoming key presses andresults in an invocation of the appropriate function within the logicalAPI.

As much validation and state-based logic as possible exists inside thisLogical API function so that external commands are treated the same andexecute the same code as key presses. This API can be implementedwithout a major redesign of appliance control software. Only theCustomer Interface Manager software must be reorganized and grouped tocall API functions as the entry point for each key press command. Thisis not a requirement of the software architecture 10, however. It onlyserves to minimize the amount of code that must be written. If acollection of Logical API functions is not available to the externalcommand engine, then validation and state logic found scattered in theappliance control must be duplicated for each external command,resulting in larger code size and increased possibility for error.

Identification: Multi-Node Issues

The discussion above on API Versioning and Discovery established abenefit for a mechanism to discover the APIs resident on any one nodehaving the software architecture 10 installed thereon. Taken to the nextstep, there are additional considerations:

-   -   1. Multiple Nodes    -   2. Multiple Clients    -   3. Multiple installed Nodes which implement the same API    -   4. A single Node with multiple duplicate APIs    -   5. Multiple APIs Using the same Op Codes    -   6. SAP Assignment    -   7. Client Discovery of the Nodes supporting the software        architecture 10 Protocol

Multiple Nodes. It is probable that multiple components on the networkwill implement the software architecture 10. Therefore, considerationsshould be made for networks with multiple components which implement thesoftware architecture 10.

In a façade pattern model, the façade pattern is used to create simpleaccess to a collection of objects. This is done by creating aninterposing software layer between the client and the various targetobjects so that the client has a simple interface to a single object.This single source is then responsible to forward requests to theappropriate target object. In the façade pattern model, this model iseasier to manage because the API is centrally defined. In mostapplications, the façade presents a simpler interface to the client.However, this model requires compile time design to include other nodes'APIs into the façade node. Additional RAM/ROM can be required for thefaçade to handle and forward requests to the target node. And, if twonodes are clients to one another, then the façade pattern would createunneeded processing, as the façade node would first make request throughhis own façade only to forward those to the target node.

In a distributed services model, this method uses discovery protocol asthe means for the client to find the target objects. The client isresponsible for the independent interaction with each target object. Inother words, the client will discover the software architecture 10node(s) and then will interrogate each as to what API(s) are supportedby each node. In the distributed service model, this model scales wellsuch that components can be plugged together at runtime. However, thismodel can require multiple documents to manage the network variabledefinitions (APIs).

It has been determined that the software architecture 10 will use thedistributed service model for managing multiple enabled nodes on thenetwork 14. The façade approach can be undesirable because changes tothe target object API require changes to the façade (change, compile,download, test). Whereas in a single compile time environment supportedby good re-factoring tools, façade could be a good choice. In adistributed environment, the more flexible distributed service modelwill allow for faster development and flexible configurations. However,in some cases there may not be enough resources on each microprocessorin the system to support the software architecture 10. In other cases,there may be legacy protocol and there is no desire to makemodifications to a legacy board. In these cases, façade can be a goodalternative to the distributed service model.

Multiple Clients. As shown in FIG. 1, multiple nodes or clients 16 onthe network 14 will implement the software architecture 10. Therefore,considerations should be made for networks with multiple occurrences of10. One major consideration is that of event registration andnotification. If multiple clients register with the softwarearchitecture 10 for events, the software architecture 10 should be ableto manage the event distribution.

Using a node ID directed message eventing model, the softwarearchitecture 10 will store the Node ID(s) of each event requester suchthat when that event is triggered, a directed message will be sent tothe requesting Node(s). In this model, messages are only sent to nodesthat care about the event. However, this model requires one byte permessage to store the Node ID and requires more RAM to create additionalmemory structures for each requesting node.

In a node ID directed message eventing with API ID Identifier, usingthis approach, the software architecture 10 stores the node ID(s) ofeach event requestor such that when that event is triggered, a directedmessage is sent to the requesting node(s). In addition, the API ID ofthe host node is included in the event. This model allows the clienttransport layer to better route messages internally. However, this modelalso requires one byte per message to store the API ID and requires moreRAM to create additional memory structures for each requesting node.

In a broadcast message eventing model, using this approach, the softwarearchitecture 10 does not track the node ID of the event requester. Whenthe event is triggered, the software architecture 10 sends a broadcastmessage. In this model, the software architecture 10 implementation issimpler and smaller, there is no need to spend one byte per message tostore the Node ID. However, broadcasting can create unnecessary eventprocessing by other nodes.

A forth, hybrid approach, which is the preferred approach, comprises amodel where broadcast messages are used which eliminates the need tostore Node Id. However, the client will include API Id and Op Code inthe Event Creation Messages of the DAQ (API Id 2, Op Codes 1, 2, 12, &13) such that they are dynamically assigned (as discussed in theparagraph below). Using this approach, the resultant event message willcontain the assigned API Id and Op Code (as shown in the publishEventmessage of API Id=1) In this message (publishEvent), the API Id and OpCodes of Bytes 1 and 2 of 28 in FIG. 4, are those assigned by the client16 using the Event Creation Messages (cited above).

It has been determined that the software architecture 10 describedherein will use the broadcast messaging model which includes the API IDand Op Code. This will provide the benefit of routing by trading API IDstorage for Node ID storage. Given the discussion on SAP below, the riskof broadcast messaging is much lessened. And although some amount ofprocessing will be used by the nodes to discard messages not relevant tothem, it is superior to directed messages which could eventually causesaturation of the network and of the software architecture 10 code.Including the API ID allows the client to configure the control withdynamic APIs which will encourage better, modular designs in the future.

Using the Same API on Multiple Nodes. It is probable that some optionalnetwork component will implement the same API as does the UI orAppliance Manager board (i.e. service/diagnostic or energy). This willallow the optional network component 16 to manifest itself to anexternal client 22. Thus, the software architecture 10 can permit theclient 16, 22 to interact with two physical nodes—each implementing thesame API. This design consideration is at the intersection of severalothers, and likewise, its resolution is a combination of pre-existingdesign solutions.

Optional nodes are possible through dynamic membership. The client willbe able to find out which nodes support the protocol 28 through thediscovery API (see FIG. 6). Each node may be interrogated to find outwhat APIs are supported through discovery as well. Op codes are notglobally unique, but the internal communication network 14 node idcoupled with the API ID and the Op Code are unique. The API ID isembedded into each event.

To summarize, the client may first discover the software architecture 10nodes and then discover the support APIs of each. The client may theninitiate an interaction with each API of each node. As each packet 24includes both the node ID and the API ID, both client and target will beable to avoid namespace conflicts and route messages to the appropriateapplication space.

Multiple Instances of APIs on the same Network Node. There are appliance12 designs, which lend themselves to API re-use on the samemicroprocessor. Examples would include a double oven (i.e., twoseparately-controlled baking chambers) or a two-compartment refrigerateddrawer. In other words, in some cases there are multiple cavities thatperform the same function and can therefore be controlled via the sameAPI. The design approach for this case is discussed.

In a unique function name model, the designer will create an API ID thathas unique Op Codes for each command or variable without concern forre-using the definition. In other words, Op Code 10=lower oven set tempand Op Code 11=upper oven set temp. In this unique function names model,there is less messaging during discovery, however, this model does notpromote modular design and code reuse.

In a multiple API ID model, the designer uses the same Op Codedefinition, but will designate a unique API ID for each instance of theAPI. In other words, upper oven API Id=1, lower oven API Id=2. In thismodel, there is less messaging during discovery and this model promotesmodular design and reuse. However, this model will result in consumingthe available API IDs at a faster rate.

In an instance ID model, the software architecture 10 dynamicallyassigns the API ID to each instance of the API except for the firstinstance. The first instance of the API will be identified by a globalAPI ID repository. To enable this, the software architecture 10specifies API IDs (e.g., 246-255) as reserved APIs for dynamicassignment to API instances. This model promotes modular design and codereuse, and does not consume API IDs. However, there is more messagingduring discovery.

The software architecture 10 is an object oriented protocol designed toallow objects to discover and collaborate with each other in a robustmanner. Basic to these requirements are: (1) collaboration entities mustbe uniquely addressable so that messages can be appropriately routed onthe network and (2) collaboration entities must be uniquely identifiableso their messaging contracts, rules for interaction, and compatibilityconcerns may be understood. In a single runtime environment, thecompiler is capable to enforce item (2). In a networked or distributedenvironment, embedded compilers do not generally address item (2).

Collaboration entity (object or API) addressing uniqueness is governedby the combination of a 3-bit node ID (found in the Address Field of 24in FIG. 4) and an 8-bit API or Instance ID (found in Byte 1 of 28 inFIG. 4). Any network message containing these two pieces of informationcan be correctly routed. This provides for 255 unique collaborationentities (or objects) for each network node.

Entity identification is defined by an 8-bit API ID (e.g., a classidentifier), a 2-byte Type ID (i.e., sub-class or specialization), and a2-byte version ID (i.e., Type ID means intent and Version ID meanscompatibility).

This two-tiered approach recognizes uniqueness of addressing separatelyfrom uniqueness of identification. This separation provides for a moreefficient use of bandwidth by removing four bytes of identificationinformation from each packet. In turn the client must cache theidentification information and index it by the eleven total bits ofaddress.

It has been determined that the Instance ID model is a preferredembodiment of this invention. The Discovery API (API ID=3) has supportfor the Instance ID in messages, Publish API Info, Get Instance Info,and Publish Instance Info. Instancing is a very powerful concept, whichcan be exemplified by its use in the protocol.

API-Op Code Namespace. Messages on a serial network generally have aASCII or numeric identifier which allow the receiver of the message toroute the data contained in the message to the appropriate internalfunction. This function will then operate on the remaining data in thepayload.

The remaining data in the payload is defined at design time in adocument. This document describes the meaning of each bit and/or byte inthe payload. From this, internal software message handlers are developedspecifically for each payload definition. Therefore there is, ingeneral, one message handler for each unique Op Code and Cmd/Fb pair.

Normally, if there were multiple independent payload definitions thatshared the same Op Code without any additional identification mechanism,it would be impossible for the receiver to route that message to theappropriate message handler. However, this invention provides the Cmd/Fbflag to support the overlap of Op Codes using, the flag fordifferentiation. Thus, this invention provides the functionality tooverlap a command and its corresponding feedback message using the sameOp Code.

This section discusses techniques that can be employed to provide uniqueidentification to message payload definitions.

In a globally-unique Op Code model, using this approach, Op Codes mustbe globally unique. In other words, each platform or API developer mustbe allocated an Op Code range (e.g., 350-385) which must not overlapwith the Op Code range of any other project. This model is inefficientdue to range allocations which require spare IDs. Further, APIdevelopers will not have control over their Op Code numbering scheme andthis model requires an order of magnitude more coordinated decisions(information handoff).

In a globally-unique API ID model, using this approach, Op Codes aregrouped into logical collections forming an API. The API will beassigned a globally unique ID composed of API Id, Type, and Version.Therefore, thy Op Codes therein need only be unique within the API. Inthis model, there is no need for allocated spare IDs, API developers canstart at Op Code=1, and this model requires less informationcoordination to avoid namespace conflicts.

It has been found that this invention employs the globally-unique API IDstrategy as a preferred embodiment. Certain fixed Op Codes, which arepart of the software architecture 10 Core API, revert to the commonstarting number (1) and the Core API can preferably be assigned an APIId of (1).

SAP Assignment. SAP found in 24 identifies the structure of the WidePayload or SDU 26 It is the same concept as an API ID, which wasintroduced earlier herein. The advantages of SAP are also the same, inthat incoming messages need to be identified and routed to the correctinternal handlers (or quickly discarded). In the example WIDE network 14discussed herein, there are sixteen available SAPs. The softwarearchitecture 10 fits the criteria for SAP membership. In this scenario,the internal communication network 14 administrator can approve thesoftware architecture 10 application protocol and assign the softwarearchitecture 10 an official SAP. Other network identifiers for theprotocol 24 are contemplated without departing from the scope of thisinvention. For example, the software architecture 10 can be assigned adefault SAP of 1 on the internal network 14.

A SAP (or other sub-protocol identifier) allows the internalcommunication network 14 node to participate in the softwarearchitecture 10 and non-architecture 10 messaging. The softwarearchitecture 10 SAP fits into global architecture, and adds more scopeto the software architecture 10. The internal communication network 14SAP is a sound concept from both a technical and practical perspective.Securing a network 14 specific ID provides the software architecture 10with global visibility and official acceptance which can help toproliferate its use and propel it to a global standard.

The software architecture 10 Discovery FIG. 5. In the previous section,it was established that the software architecture 10's API ID isanalogous to the internal communication network 14's SAP. Likewise, inprevious sections, it is established that it is advantageous for thesoftware architecture client 16 to discover by interrogation the API(s),which reside on each physical node of the software architecture 10.

A similar question and/or solution can be presented for the softwarearchitecture 10 discovery. If a service tool wanted to dynamicallydiscover all of the software architecture 10 API(s), it would first needto discover the Node IDs of the internal communication network 14node(s), which supported the software architecture 10 protocol. This canbe accomplished by a broadcast message model which sends a broadcastcommand which the software architecture 10 nodes will respond to. Inthis model, the software architecture 10 can broadcast a new API whichis added to the software architecture 10 or can broadcast the additionof a new network 14 node(s) which implement the software architecture10. The Discovery API, FIG. 6 which will serve as the mechanism for thesoftware architecture 10 discovery. There can be both a pollingdiscovery message and an unsolicited broadcast message available and isdiscussed in the Discovery API (API ID=3).

Multi-Payload Message Integrity

Frag, bit 6 of Byte 2 in the software architecture 10 header, enablesthe software architecture 10 protocol to send payloads greater than thatof the underlying protocol (i.e. that of the internal communicationnetwork 14). When Frag is set, the receiver should realize that thecurrent message will be fragmented into multiple packets or fragments.

In the message-fragment id model, the first fragment of a fragmentedmessage uses the standard packet structure as described in FIG. 4. Thisinitial fragment provides the message's API, Op Code, and Cmd/Fb flag.All subsequent fragments of the message will preferably assume thefragmented message structure described in FIG. 24. In this structure,the Frag flag still exists (along with the MMP flag) to reinforce thedata. However, Byte 2 now contains the more fragments pending flag (MFP)in bit 5, message id (MID) in bits 3-4, and fragment id (FID) in bits0-2.

The MFP flag informs the receiver that at least one more fragment of thecurrent message should be expected. The transition of MFP from 1 to 0informs the receiver that the current packet is the final packet of thecurrent message. MID provides an 2-bit identifier for each message.Thus, each fragmented message (group of fragments) will be assigned aMID, and this MID will then increment for each subsequent fragmentedmessage (group of fragments). The MID will increment to 3 and thenrollover back to 0. FID provides a 3-bit identifier for each fragmentwithin a message. Thus, for a particular message, the first fragmentwill always be assigned and FID of 0. For each subsequent fragment ofthat message, the FID will be incremented. The FID will increment to 7and then rollover back to 0.

The fragmentation protocol provided by this invention allows thereceiver to check the integrity of a fragmented message. By monitoringthe Frag and MFP flag, the receiver can ensure no erroneous halts to afragmented message. By checking that the MID does not change withinreception of a single fragmented message, the receiver can ensure thattwo separate fragmented messages do not become merged (perhaps due to alost fragment). By checking that the FID correcting increments perfragment, the receiver can ensure that not fragment is lost within amessage (or received out of order). See FIG. 25 for an example of themessage-fragment id model.

In a summary CRC model, this solution makes use of a well-known existingcyclic redundancy checksum (CRC) concept. An additional two-byte CRC canbe appended to the last payload of a multi-payload message. The CRC isthe CRC representation of all payload bytes concatenated into a singlecombined payload. The sender generates this CRC. The receiver validatesthis CRC according to well-known methods. In this summary CRC model,this solution re-uses existing CRC algorithms which are established andwell known, however, the CRC algorithm is more complex than framecounter and the CRC may not be easily portable to a third party vendor.

Therefore, it has been determined that the message-fragment id model isa preferred embodiment for confirming multi-payload message integrity inthe software architecture 10 according to the invention. Themessage-fragment id model is easier to implement for third parties andis easier to add to the existing architecture 10.

Software Organization

With respect to the software architecture 10, the code organization andimplementation files will now be discussed with respect to FIG. 10. FIG.10 is a schematic illustration showing the software architecture 10 ofFIG. 1 according to the invention in relation to the software operatingenvironment 16A of a component 16 containing various software components16B wherein the software architecture 10 comprises a command handler 50,an update handler 48 and an internal communications network layerinterface 52 for interconnecting the software architecture 10 to theinternal communications network software operating layer 14A, whichcreates and sends data over the communications network 14 of thehousehold appliance 12. Also shown is an example of how other softwarecomponents 16B within the software operating environment 16A wouldinvoke on and interact with the components of the software architecture10 (50, 52, and 48).

In order to create a more generic implementation of the softwareoperating environment 16A, the dependency between the UI Manager (whichis one of several software components 16B within the software operatingenvironment 16A) was eliminated. In this implementation, the Mainexecution loop 11 of the software operating environment 16A executes theinvocation onto 50. It was previously believed that the previousimplementation afforded more accurate and robust performance of thesoftware architecture 10 due to the particular timing details associatedwith the execution timing associated with UI_Manager 16B.

To define the first level of detail for the software architecture 10,three main software components (sub-components) are shown: the updatehandler 48, the command handler 50, and the internal communicationsnetwork layer interface 52. The update handler 48 interacts with the DAQengine 30 in order to identify information flagged for updates withinthe operation of the DAQ such that the internal communications networklayer interface 52 can process said information resulting in interactionwith internal communications network software operating layer 14Aresulting in a packet structure 24 transmitted onto network 14. Thecommand handler 50 validates and processes incoming commands from theinternal communications network layer interface 52 invoking onto theappropriate software operating function according to the Identifiers APIId and Op Code values of packet structure 28. The internalcommunications network layer interface 52 is meant to decouple (as muchas practicable) the particulars of the software architecture 10 from theinternal communications network software operating layer 14A, thenetwork 14 of FIG. 1, and the packet structure 24 of FIG. 4. Theinternal communications network layer interface 52 interfaces with theinternal communications network software operating layer 14A, whichcreates and sends data according to the definition of FIG. 4 over thecommunications network 14 of the household appliance 12.

Software operating layer sub-components 48, 50 and 52 of the softwarearchitecture 10 shown in FIG. 1 work together to manage communicationswith other components 16 or 22 which also have the software architecture10 or an alternative capable to interact with packet structure 24.

FIG. 34 shows several implementation files which are contemplated foruse with this invention.

SA_prm.h. The software architecture 10 includes configurable parametersand command enumerations.

SACore.c/.h. This file for the software architecture 10 core softwarecontains the update handler 48 and command handler 50 which processescommands, manages flow control feedback, and takes snapshots ofappliance data for dynamic updates.

SAAppSpecific.c/.h. This file for the software architecture 10 coresoftware contains appliance-specific command handlers and commandimplementations for driving a particular type of appliance 12 (such as afile specifically directed for management and communication with awashing machine, for example). Any command that is not generic to allappliances 12 is implemented in this function. These commands areenumerated in SA_prm.h and are called by the command handler.

SAWideComm.c/.h. This file contains the internal communication network14 application layer 52 which provides the interface to the internalcommunication network 14 protocol and controls bounding of messages intosnapshots, parsing incoming commands, and processing update flags tosend out update messages.

SADaq.c/.h. These files contain all functionality for the DAQ engine 30.Thus, all functionality concerning the update handler 48 and eventing iscontained here.

SADiscovery.c/.h. These files contain all functionality for a nodeimplementing the software architecture 10 to discover other nodes (andthe corresponding functionality of) other nodes which implement thesoftware architecture 10.

SAVariableMap.h. This file contains the embedded variable map whichallows for event creation by an external client without knowledge of avariables address in memory.

FIG. 11 illustrates an example interface of the software architecture 10with an appliance control where the software architecture 10 of FIG. 1is thrice invoked from the supervisory scheduler (MAIN) according to theinvention. Also shown is MAIN's invocation onto WIDE.WideExec( ).WIDE.WideExec( ) subsequently calls back onto the software architecture10 according to FIG. 33 where the component of the software architecture10, WideCommHandler, exposes functions. SA_AcceptData( ) andSA_BuildData( ). Also shown is MAIN's invocation onto SA_WideComm( )(also a function exposed by a component of the software architecture 10)which ultimately results in the invocation shown in FIG. 33 onto thefunction WIDE.QueueMsg( ) of the component WIDE of the softwareoperating environment 16A.

FIG. 13 is a schematic illustration of the example implementation of thesoftware architecture shown in FIG. 11 including an applianceinitialization section. The initialization function calls SA_Init( )from an initialization routine before entering the main execution loopshown in FIG. 11.

The table following this paragraph illustrates a documentation exampleof how APIs will be managed, including the mechanism of CompilerDirectives to control the deployment of the functionality exposedthrough the APIs of the software architecture 10. API Compiler ROM RAMAPI Name ID Type Version Directive Use Use Notes CORE 1 1 2 SA_COR 181043 Based on 30 dynamic events registered Data Acquisition (DAQ) 2 1 2SA_DAQ 1658 373 Based on 30 dynamic events registered (10 bytesRAM/event) Data Acquisition Extended 2 2 1 SA_DAQ_EXT SA_DAQ + DAQ Basedon 30 dynamic events (includes SA_DAQ) 1064 registered (includes SA_DAQ)Discovery 3 1 1 SA_DISC 516 3 Debug 4 1 1 SA_DEBG Low Level 5 1 1SA_LOLV Key Press 6 1 1 SA_KEPR Memory - Port API 7 1 1 SA_PORT 342 0Energy Management 8 1 1 SA_ENGY GMCL 9 1 1 SA_GMCL Poll Variables 10 1 1SA_POLL Service and Diagnostics 11 1 1 SA_DIAG Unused (140-240)Non-Standard (241-245) Reserved for API Instance Id (246-255)

In the above table, API Ids in the 241-254 range can be used withoutconsideration for standards. They are intended to allow a designer theflexibility to use the software architecture 10 in an application wherethe expectation of re-use is minimal. In such cases, this will eliminatethe need to develop a specific API Id and Type for a collection ofmessages which are expected to be a ‘one off’. These Ids can also beused for candidate standard APIs which have not yet received theirofficial ID. Additionally, in the above table, the RAM and ROM estimatesare taken using Motorola HC08 Cosmic Compiler version 4.3f with thesoftware architecture 10 configured to have 30 dynamic events allowed(i.e., heap size=300 bytes), 7 APIs defined, and a maximum command sizeof 15 bytes.

FIG. 14 is a schematic illustration of a virtual router incorporatingthe software architecture of FIG. 1 according to the invention showing amapping between a pair of software architecture implementations. Thevirtual router of FIG. 14 is a software design which encapsulates theAPI implementations (objects, see APIs 1-8 in each side of the router ofFIG. 14) of the software architecture 10 such that the collaborationbetween an embedded client (application logic, algorithms, closed loops,sequencers, and state machines) and embedded components (the softwarearchitecture 10 API implementation: objects like defrosters, heaters,temp sensors, valves, etc.) is uniform and identical regardless if theentities collaborate over the network or share a runtime environment.

FIG. 14 shows six unique collaboration examples labeled as suchillustrative of how a pair of software operating environments 16Aexisting on separate hardware components 16 and connected by a network14 will use the various software components 16B of the softwareoperating environment 16A to create transparent access between theoperating logic of 59 and the software components 16B of both the righthand and the left hand software operating environments.

Prior to describing the collaboration examples, a description of thestructure of FIG. 14 should aid in the understanding of thecollaboration examples. Each software operating environment 16A containsrepresentations of a sub-set of useful software operating components(16B) contained, including: the software architecture 10, internalcommunications network layer interface 14A, the DAQ 30, and a hardwareabstraction layer 80.

The hardware abstraction layer 80 comprises: a mechanism therein toencapsulate the particular fixed address of the connected electricalcircuits on which the software operating layers of 80 will operate; andsoftware interfaces (28, 28A, or 82) encapsulating occurrences of 16B inthe form of (one of the following): 28 the packetized representation (anordered collection of bytes) of a message exchanged by the softwarearchitecture 10, 28A the packetized representation (an orderedcollection of bytes) of a message exchanged by the software architecture10 representing only the application payload 28A (the valid dataarguments) expected by the software operating component 84 or 86, 82 analternate representation of either 28 or 28A where the intent and datavalues and resultant actions are functionally identical but not of theform of an order collection of bytes. 82 is in the form of a uniquesoftware function having arguments represented by individual namedvariables whose value is derived from 28A or represented by an orderedcollection of bytes derived from 28A.

Application GDMs 84 (Global Design Modules) are variants of 16B known asglobal design modules which are standard software operating componentshaving been subjected to a standard development process includingfunctional and non-functional requirements, testing, documentation, andimplementation guidelines. Application GDMs address appliance specificconcerns such as defrosters, heaters, door closure. Application GDMs canbe classified in at least 2 variants. Variant contains specificapplication logic apart from 59 used to govern the behavior and gatherinformation from a collection of other software operating componentsincluding a plurality of other 84(es) and 86(es). Variant 2 containsspecific application logic apart from 59 used to govern the behavior andgather information from a specific electromechanical device or sensorsuch as a heater, evaporator, motor, valve, solenoid, relay, pressure ortemperature sensor. Variant 2 may be configured to address specificconcerns made relevant by the specific manufacture's variant of thedevice, by the particular configuration of the device based on the usagemode determined by the application requirements (i.e. Scaling values),or by a confluence of factors which create specific concerns notmentioned heretofore.

Infrastructure GDMs 86 address specific recurring concerns which areindependent of the application of the system architecture of FIG. 1.They can be re-used across a plurality of appliances such asrefrigerators, cooktops, dishwasher, dryers, clothes washers, etc.Infrastructure GDMs can be classified in at least 2 variants. Variant 1is associated with a particular concern resulting from a recurringcombination of electrical components or electrical constraints. Someexamples are: manufacture interface constraints, device duty cycles,electrical load characteristics examples of which are inrush and steadystate current limits, or other constraint such as the mode of analogconversion to digital examples of which are 4-20 mA current loops vs.0-5Vdc analog voltage feedbacks. Variant 2 is associated with applianceand application independent software components known as utilityfunctions. They provide logic used by other 16B components including 59and 80. Variant 2 may contain or use references to Variant 1 of 86.Examples include timers, zero cross detection, and other useful softwarecomponents whose purpose is more utilitarian than driven by applicationor electromechanical requirements.

An embedded virtual router 70 provides an encapsulating layer by whicharchitectural dependencies (the method by which one component 16B isaccessed by or exposed to another 16B [examples of 16B are 30, 84, 86]within or between at least two software operating environments connectedby 14) between the application logic 59 (of the software operating layer16A of the component 16) and the components comprised by the hardwareabstraction layer 80, DAQ 30, another instance of application logic 59or component therein, or any other useful component 16B are minimized oreliminated.

A software component 72 used by other software components 16B to obtainreferences to any other software components 16B where the obtained 16Bmay be part of a software operating environment 16A existing in or on:the same hardware component 16, a different hardware component 16connected by 14, a different hardware component 22 connected by acombination of network segments including 14, or a different hardwarecomponent 16 of a different appliance 12 connected by 14, a combinationof different network segments between the two occurrences of 12, and the14 of the first appliance 12.

The software component 72 also provides the mechanisms for othersoftware components residing within the same software operatingenvironment 16A to publish the necessary identification and/or routinginformation into the memory of 72 such to enable the aforementionedenumerated uses of 72. The identification and routing information may beassociated with components residing within the same software operatingenvironment or the identification and routing information may beassociated with components apart from the components residing within thesame software operating environment, but are known by componentsresiding within the same software operating environment.

Structures 74 in the memory of 70 are able to receive messages orprovide functions for invocation of messages and are able to sendmessages or provide callback functions for the distribution ofinformation. These structures having an access definition of 28, 28A, or82 corresponding to an occurrence of a software component such ascomponents within 80, 59, or any other useful software component locatedin the aforementioned enumerations of 72 and the capability to route theinformation to that software component or to an appropriate intermediatesoftware component having the same or similar purpose of 74.

Looking now at the possible collaboration examples, it is expected thatthe structures 74 of 70 will be created and populated based on discoveryqueries containing requests for access to specific software components16B which are both identifiable and routable, invocations implying saidaccess, or by software components 16B which are able to invoke on 70 onbehalf of themselves or other components 16B resulting in creation andpopulation of structures 74.

Collaboration 1: a command is issued by software component 59 of theright-hand software operating environment 16A and received by a softwarecomponent contained in the collection of 74 with an identifier of API 1within component 70 of the same software operating environment. Usingthe identification and routing information contained within 70, thecomponent identified by API 1 transmits the received information throughthe other local software operating layers 10 and 14A, and finallytransmitted over 14 and received by 14A of left hand software operatingenvironment. The message is then handled by 10 and routed to theappropriate component within 74 of the left hand software operatingenvironment. The appropriate 74 of the left hand software operatingcomponent using identification and routing information contained within70 of the same software operating component then invokes on or sends themessage to the local implementation of API 1 contained in the left handsoftware operating environments hardware abstraction layer 80. Thus theapplication logic within software component 59 of the right handsoftware operating environment invoked a function implemented in thesoftware operating environment of the left hand side without informationcontained therein for the realization of said invocation. Therefore, thevalue of the design implied by FIG. 14 is that application logic 59 isre-useable with respect to the location of the of the other softwareoperating components 16B within a plurality of software operatingenvironments 16A connected by a network 14 or a plurality of networksegments which may include 14.

Collaboration 2: In this case, the initiation of the message is from 59of the left hand software operating environment 16A. Illustrated is thecase where the final invocation is on a software component (in this caseAPI 2) within the same software operating environment using the samemethodology described in greater detail in Collaboration 1. Therefore,in Collaboration 2, an alternative architectural disposition between anoccurrence of Application logic 59 to some other useful softwarecomponent (API 2 of Hardware abstraction Layer 80) is shown to have noeffect on the implementation of either. And furthermore, it is thepurpose of software component 70, also being able to comply with theIdentification and interface requirements imposed by the softwarearchitecture 10, to provide this capability.

Collaborations 3-6 show additional uses for the Embedded Virtual Router70. The mechanisms used to accomplish these variants are the same asdescribed in Collaborations 1 and 2. They are included to illustrate theusefulness of the design and the expected additional message patterns tobe available with respect to the DAQ 30. Local event listeners (3) andremote event listeners (4) of Application Logic 59 are provided with aninterconnection to a representation of the DAQ engine 30 providing notonly a connection to the DAQ in the local software operatingenvironment, but also to the DAQ(s) which reside in remote operatingenvironments. DAQ generated messages based on the occurrence of DAQevents can be transmitted locally (6) and remotely (5) throughmechanisms available in 70.

FIG. 15 is a schematic illustration of an atypical appliance constructedusing the architecture of 12 and comprising a persistence node 54incorporated as a component comprising the software architecture 10 ofFIG. 1 according to the invention. Whereas the state of the art inembedded systems is to provide data persistence local to the PCB, thepersistence node according to this invention provides a persistenceservice exposed to components 16 and 22 through the mechanisms of thesoftware architecture 10 and/or the embedded virtual router 70.

Various examples of the connectors and protocols (RS-232, wireless,WIDE, etc.) are shown within the components of each client whichcommunicate with one another along an internal network on each component16, appliance 12 and persistence node 54. In summary, the persistencenode 54 is a logical entity which is discoverable and useable by allcomponents 16 sharing a network 14, 20 or a runtime connection. Thisentity will provide services and protocol mechanisms necessary to read,write, and store information.

As discussed above, appliances 12 are “state” driven machines andtypically have a user interface (e.g., a keypad) using which a user caneffect a change in state of the appliance 12 (e.g., change a washer froman idle state to a “wash” state). As applications are developed thatrequire external communication with an appliance 12 (e.g., testing,diagnostics, remote control, etc.), there are three possible techniquesto perform this interface: (1) translate external commands into keypresses (see FIG. 16 and discussion); (2) use custom software to executestate-change commands (see FIG. 16 and discussion); or (3) simplytranslate key presses into a logical API (see FIG. 17 and discussion).

FIG. 16 is a schematic illustration of a prior art method by whichexternal commands are translated into key presses for testing householdappliance functionality. In the prior art method, a user would actuatean appliance 12 via one or more key presses 56 to change the state ofthe appliance (referred to in FIG. 16 as a “state machine” 12) to affectthe appliance functionality 58. In order to test the functionality 58 ofthe appliance, the user would prepare external commands 60 and either(1) translate the external commands 60 to key presses 56; or (2) preparecustom software 62 which would emulate the state machine appliance 12 toattempt to duplicate the appliance functionality 58. This can bedifficult and error prone.

In an new method of operating and testing an appliance, FIG. 17 is aschematic illustration of the interaction of user-initiated key presses56 and externally-fed software commands 60, typically from a client, areboth passed as arguments to the software architecture 10 of FIG. 1according to the invention for issuing commands to a household appliance12 to, e.g., test household appliance functionality 58 and/or change thestate (i.e., actual operation) of the household appliance 12.

The method discussed with respect to FIG. 17 is novel because, insteadof translating external messages, treating the appliance 12 as a closedsystem, it exposes the functionality of the appliance 12 independentlyof whether the message is received as an external key press or asoftware command local or remote to the appliance 12. The messages(commands) are processed through an API of the software architecture 10(now an open system as opposed to the prior art “closed” system), whilepreserving key-press validation and feedback to the user.

Currently, appliance control software is not set up to validate andexecute external commands. To remedy this, an appliance API is definedthat includes both user functionality as well as low-level machinecontrol commands. During normal operations, when a key is pressed or anexternal command is issued, it is directly mapped to an userfunctionality API function call as a common entry point (e.g., a WASHkey is pressed on a user interface [keypad] or an external WASH commandis issued will both call a setCycle(WASH) function immediately,regardless of the state of the appliance 12). All validation andstate-based behavior will exist inside this function so that externalcommands are treated the same end execute the same code as key presses56.

This API can be implemented without a major redesign of appliancecontrol software. Only a user interface software would need to bereorganized to call API functions as the entry point for any commandinstead of just reacting to key presses inside of the state machine 12.Use of this method of FIG. 17 enables the manufacture of an appliance 12to test and diagnose the keypad/user interface separately. This savestime and effort in development, diagnosis and testing of appliances.This will also eliminate the need for complex mechanical keypadactuation devices as well as mechanical actuation harnesses which wereconventionally used to test user interfaces and appliance functionality.

In addition, the appliance 12 API contains a command to send theappliance into a diagnostic or factory test mode. In this mode, allstate-based behavior and command validation code is disabled to allowfor a low-level API. API commands in this mode can access and controllow-level parts of the appliance 12 such as reading and writing toEEPROM, pressing keys (56), reading sensor values, writing to cycleparameters, actuating relays and other actuators, etc.

The API interface discussed with respect to the software architecture 10is an object-oriented software package that is effective when one object(appliance functionality) has multiple clients that need to interactwith it (e.g., both key presses 56 and external commands 60). This is anew approach because appliances do not currently contain object-orientedsoftware and are generally thought of as being a closed system andhaving only one client: user interface keys. This invention contemplatesthat appliances 12 will have many clients through the introduction of aninternal communication bus (i.e., network 14) and external connectivity20. These clients may include web applications, diagnostic tools,testing tools, and home automation systems, among others.

Appliances 12 with the API software architecture described herein willbe “future proofed” and ready for many advanced remote applications thatcustomers may request. These can include energy management, improvedservice and diagnostics tools, and remote control and monitoring. Inaddition, since the API is the entry point into all appliancefunctionality, customers can benefit from improved automated developmenttesting and factory testing of appliances 12.

The software architecture 10 also contemplates that the virtual devicemodel can be aware of the current capabilities of the physical device(the appliance 12). For example, if an oven is baking, the applianceclock cannot be modified. Capabilities synchronization is a generalsolution meant to allow a virtual model to recognize changes to thecapabilities of a device based on its state.

Currently, this purpose is achieved through code which is written perappliance 12. The solution contained in the software architecture 10replaces device specific code with a general solution. This solution iscomprised of additional messages which the software architecture 10broadcast containing the current set of invalid commands (API and OpCode). This information is evaluated at runtime so that the userinterface will be expressed in such a way that the user may only modifythose device characteristics which are modifiable, so that the customeris not given the opportunity to modify a device characteristic which iscurrently immutable as dictated by the actual device.

The software architecture 10 is a cross-product system of applicationsand tools. These applications help to increase both quality and speed tomarket in the product development process. This is done by interactingwith the data that is stored in memory inside the appliance 12.

In order to stay flexible, configurable and generic, the applicationsinteract with the appliance by specifying numeric memory locations(addresses) which are required. Each time the software in the appliancechanges, however, these locations in memory can move around and take ona very different meaning. In order to solve this problem, a variable mapfile standard and generator were created.

The variable map file generator takes the software names (textualdescriptions) written in code and associates them with the numericaddress and size of that piece of data. It then outputs this informationin a standard file format. This is executed each time the code ischanged and compiled. The information in this standard file providesindependence from both the compiler and from where data is located inmemory.

The variable map file is then read by any application that wants tointeract with a software architecture 10-based appliance 12.Applications are coded against the meaningful textual names of data,rather than the numeric addresses of data which greatly simplifiesapplication development.

The variable map file format and usage process are described in thetable below. Module Variable Name Address Size appman.h Hour_Timer 02131 appman.h Zone1 020e 3 appman.h Zone1.Act_Temp 0210 1 appman.hZone1.Zone_State_Tmr 020f 1 appman.h Zone1.Zone_State 020e 1

An example of the method used in working with the variable map conceptincludes the following steps.

-   -   1. An engineer builds an application coded against the textual        descriptive names of meaningful data located in the appliance        control.    -   2. The appliance control code changes, resulting in new        locations of the meaningful application data.    -   3. An engineer compiles the new appliance code, which also        automatically generates an associated variable map file. The new        code and variable map file are deployed together.    -   4. When the application is run against the new code, it does not        have to change, as long as it has the proper variable map file.    -   5. If new data is required by the application, it can be easily        identified or retrieved from the variable map file.

Thus, as shown above, the development engineer need only remember the“Variable Name” column in the table above, and not need to constantlylook up the constantly-changing address values in the “Address” columnsabove.

Referring now to FIG. 18, the household appliance 12, which is shown asan oven for exemplary purposes, having an internal communication bus 200can be electrically coupled to an external network 202 through a networkinterface card SIC) 204 similar to the aforementioned network interfaceconnector 20. A NIC is a well-known device that connects a computer orother client to a network, and any suitable NIC can be utilized with theappliance 12. According to one embodiment of the invention, the NIC 204is electrically connected to the internal communication bus 200 andadapts an internal communication bus protocol to a standardcommunication protocol, such as TCP/IP and GSM, so that the appliance 12can communicate with an external client (not shown) through the externalnetwork 202, such as a local area network (LAN) and/or a wide areanetwork (WAN). Thus, the external client can communicate with thesoftware architecture 10 associated with various internal components ofthe appliance 12 that reside on the internal network 14. For example,the appliance 12 in FIG. 18 is shown as comprising a user interface (UI)208 and a sensor-actuator board 210, each comprising a printed circuitboard (PCB) with the corresponding software architecture 10, and theexternal client can communicate with the software architectures 10through the NIC 204.

The NIC 204 can be mounted to the communication bus 200, which ispreferably externally exposed, of the appliance 12 through any suitablemounting means, as is well-known in the computer network art. Accordingto one embodiment of the invention, the communication bus 200 is locatedin a recess 212 defining an opening 214 that is flush with a wall, suchas a rear wall 216, of the appliance 12, as shown in FIG. 18. When thecommunication bus 200 is located within the recess 212, thecommunication bus 200 and the NIC 204, when mounted to the communicationbus 200, are protected from damage that can occur during transport ofthe appliance 12.

The NIC 204 can be supplied with the appliance 12 at the time ofmanufacture or can be purchased separately from the appliance 12 as anaccessory. Thus, a customer can choose to purchase the appliance 12without the capability to connect to the external network 202 andupgrade the appliance 12 at a later time to add connectivity, ifdesired.

The NIC 204 can communicate with the external network 202 through awired connection or wirelessly. For example, the NIC 204 can communicatewith the external network 202 via wireless infrared (IR) communicationsor other short range wireless means. In such situations, the NIC 204 ispreferably mounted to a front side 218 of the appliance 12 to facilitaterobust communication. According to one embodiment of the invention, theNIC 204 can be mounted in a recess 220 at the front side 218 of theappliance, as illustrated in FIG. 19 with respect to an oven, forexample. When mounted to the front side 218 of the appliance, the NIC204 can be connected to a rear side 222 of the appliance via wiresdisposed in a wiring conduit 224 that extends from the mounting recess220 at the front side 218 to the rear side 222 of the appliance 12,where the wires enter the appliance 12.

Another example of wireless communication is radio frequency (RF)communication. For example, a RF printed circuit board (PCB) 226 can belocated inside the appliance 12, which requires connection between theRF PCB 226 and an externally mounted antenna. Alternatively, the RF PCB226 can be mounted externally of the appliance 12, but thisconfiguration requires an electrical connection between the RF PCB 226and appliance control electronics, and an installer must open a cabinetor case 228 of the appliance 12 during installation of the RF PCB 226.According to one embodiment of the invention, the RF PCB 226 is mountedwithin the appliance 12, and a non-metallic safety barrier 230 that is apoor conductor of heat and electricity is provided as part of theappliance case 228. An exemplary safety barrier 230 is a plastic window,such as a Plexiglas window, integrated with the appliance case 228, asshown in FIG. 20 for an appliance 12 in the form of an oven forillustrative purposes. The safety barrier 230 allows for RFcommunication with the internally mounted RF PCB 226 without an externalantenna and prevents human contact with excessive heat or electricity.

Referring now to FIG. 21, the appliance 12 can be configured withhardware to facilitate service and diagnostics of the appliance 12. Inone embodiment, a service module 232 adapted to removably connect with astandard communication bus on the appliance 12 is configured to recorddiagnostic data, such as by communicating with the software architecture10 on the internal network 14. The service module can readily connect tothe internal network 14. The connection of the service module 232 to theappliance 12 is represented by step 1 in FIG. 21. The service module 232is then removed from the appliance 12 and connected to a personalcomputer 234, such as through a USB port or other suitable standardcommunication bus. The connection of the service module 232 to thecomputer 234 is represented by step 2 in FIG. 21. After the servicemodule 232 is connected to the computer 234, the service module 232connects to the Internet, preferably automatically, and uploads thediagnostic data to a remote client (not shown), as indicated by step 3in FIG. 21. The remote client processes the diagnostic data to identifyan appliance problem or failure and potentially prevent a service callor, if the problem or failure requires a service call, to optimize theeffectiveness and efficiency of the service call. Optionally, theservice module 232 can download customized testing scripts based on thediagnostic data to run tests on the appliance 12 to further diagnose oreliminate the problem or failure. Reconnection of the service module 232to the appliance 12 to execute the testing scripts is represented bystep 4 in FIG. 21.

An exemplary architecture for the service module 232 is illustratedschematically in FIG. 21A. The service module 232 comprises a pair ofcommunication buses, such as external serial buses. According to theillustrated embodiment, the service module comprises a USB 236 at oneend for connection to the personal computer and an RS-232 (EIA-232) bus238 at an opposite end for connection to the appliance 12 andparticularly to the software architecture 10 residing on various nodesof the appliance internal network 14. The service module 232 furthercomprises memory 240, such as flash memory, for storing the diagnosticdata, the testing scripts, and other data. The flash memory 240communicates with a service logic 242 that controls the operation of theservice module 232.

FIG. 22 illustrates an alternative hardware architecture for service anddiagnostics of the appliance 12. This architecture is similar to thatshown in FIG. 21, except that the personal computer 234 is replaced witha telephone line 244, and the service module 232 is adapted forconnection to the telephone line 244. Thus, the alternative architectureof FIG. 22 is more suitable for appliance users who do not own apersonal computer or do not have a personal computer connected to theInternet. The process for obtaining diagnostic data is the same asdescribed above with respect to FIG. 21; however, rather than connectingthe service module 232 to the personal computer 234, the user connectsthe service module 232 to a standard telephone jack 246, and the servicemodule 232 automatically connects to the Internet through the telephoneline 244.

Referring now to FIG. 22A, the service module 232 for use with thesystem shown in FIG. 22 is similar to the service module 232 illustratedin FIG. 21A, except that the USB 236 is replaced with a telephone lineplug 248, such as an RJ11 plug, for connecting a modem 250 of theservice module 232 with the telephone line 244 to establish a connectionto the Internet.

The service modules 232 described above can be supplied with theappliance 12 at the time of manufacture or sold as an accessory duringor after the sale of the appliance 12. Other various types of accessorymodules can be provided with the appliance 12 or purchased later by acustomer for upgrading the appliance 12. An exemplary accessory modulecan comprise a display operably connectable to the internal network 14and the external network 202 and visible to the user when mounted to theappliance 12. The display can communicate various data the user,including, but not limited to, data, such as operational status, relatedto the appliance and obtained via the software architecture 10 on theinternal network 14, or information downloaded from the Internet throughthe external network 202. An exemplary accessory module is a weatherstation module 252, which is shown in FIG. 23 as mounted to an appliance12 in the form of a refrigerator for illustrative purposes. In additionto displaying weather-related information or other information that canbe downloaded from the external network 202, the display of the weatherstation module 252 can also include one or more touch pads or a touchscreen 256 with selector areas 254 for controlling various operations ofthe refrigerator, such as for controlling an ice dispenser and a light,and for accessing settings, such as temperature, of the refrigerator.

FIG. 24 illustrates the preferred packet structure for a fragmentedmessage. Such a packet structure is preferably used for communicationwhen the message payload is larger than that of the underlying protocol.This fragmentation packet structure was previously described in thediscussed concerning multi-payload message integrity; however, as briefsummary can be listed here. In a fragmented message, the standard packetstructure described in FIG. 4 is preferably used in the first fragment.All subsequent fragments preferably use the packet structure describedin FIG. 24. The difference between these protocols is in Byte 2.

For the entirety of a fragmented message, the Frag flag should bet set.The MFP flag (more fragments pending) should be set until the finalfragment of the fragmented message. MID (message id) gives eachfragmented message (the group of fragments) a handle or id, preventingmerging of separate fragmented message. FID (fragment id) gives eachfragment of a fragmented message a handle or id, allowing the detectionof a lost fragment. A more in-depth explanation can be found in thediscussion on multi-payload message integrity.

FIG. 25 provides example operations of the fragmentation protocoldiscussed given in FIG. 24. Explanation of this protocol can be found inthe multi-payload message integrity section.

FIGS. 26A and 26B represent alternate architectures for locating theaddress and Identifier information such that well formed messages can beconstructed and sent to the software architecture of FIG. 10 resultingin event creation within the DAQ 30 of FIG. 5. As previously mentioned,the DAQ engine 30 requires a variable's memory address for eventregistration. FIG. 26A illustrates an example of using theclient-configured data acquisition scheme in which the client (computeror other client) holds a current memory map that relates a variable'sname to its memory location. This memory address, in addition to theIdentifier (API Id and Op Code), is used to construct a well formedmessage which is sent to the DAQ resulting in DAQ event creation. FIG.26B illustrates an example of using the client-configured dataacquisition scheme in which the client (i.e. another control board) doesnot know the memory address's of desired event variables. In this case,the client can utilize the embedded variable map functionality of theinvention. Thus, the client must only provide an API and Op Code and isnot required to include the memory address of the variable in the wellformed message to be sent to the DAQ. Because, in this case, thesoftware of the DAQ performs the additional task of acquiring the memorylocation of the variable specified by the Identifier. Once acquired, theDAQ uses the same function calls referenced in the previous case of FIG.26A to create the event structures in the DAQ's array of eventstructures contained in the DAQs memory heap.

Variable map information in FIG. 26A relates variable symbolic names totheir address in the memory of 16A. FIG. 26B relates variableIdentifiers (API Id and Op Code) to their address in the memory of 16.The rational for the alternate architectures is that these support bothinteractions with a human actor who might find it advantageous to workin symbolic names (which tend to be meaningful and communicate will theusefulness of the variable) and interactions with other instances of thesoftware architecture 10 or some component 16 or 22 or some othersoftware component which is able to interact with the softwarearchitecture 10. In software based interactions (non-human interactions)it is advantageous not to use symbolic names as they require more memoryto store, more bandwidth to transmit, and more computational cycles toprocess. Instead, numeric identifiers can be substituted for symbolicnames. The software architecture 10 uses the numeric identifier API IDand Op Codes as numeric substitutes for symbolic names. Additionalnumeric identification is available for any valid occurrence of API Id.Where the former numeric identification is sufficient to provide aunique index per component 16 residing on the network 14 and where thelatter, the additional identification information can be obtained usinga secondary query requiring a component of the former numericidentification, API Id. Then together, API Id and the additional numericidentification (the latter) provides identification unique within thetotality of possible software components able to be represented withinthe software architecture 10.

FIG. 27 provides an example of use of the client-configured dataacquisition scheme using the embedded variable map. Here, Node Aregisters for an event on Node B using the publicly know API X and OpCode Y that links to the desired event variable. Next, Node C attemptsto register for the same event using API X and Op Code Y. Because theAPI and Op Code pair have previously been registered by Node A, Node C'srequest is rejected. However, Node C then requests data from the remote(embedded) variable map with the get Remote Variable Data command. NodeB responds with information, including the desired variable's memoryaddress. Node C then uses this memory address to register for an event,but this time with a different API and Op Code pair.

FIG. 27 can also be thought of as disclosing two message scenariosrelating to the event creation suggested in FIG. 26B. The first scenariodescribes the Messaging between Nodes A and B both of which communicatevia internal communication network 14 and which is compatible withsoftware architecture 10. In the first scenario, Node B is able tocomply with the request from Node A. The second scenario describes theMessaging between Nodes C and B both of which communicate via internalcommunication network 14 and are compatible with software architecture10. In this scenario, Node B cannot comply with the request from Node Cbecause the API Id and Op Code in message 3 has already been allocatedby a previous request. In this case, Node B responds appropriatelyresulting in a query (5) from Node C resulting in a network message (6)from Node B containing the necessary information allowing Node C tore-create the same NVOEvent memory structure of FIG. 33 with an API Idand OP Code unique to the DynamicMemoryHeap of FIG. 33 of Node B'ssoftware architecture 10.

FIG. 28 illustrates the configurable event notification functionalityprovided by this invention. Preferably, events would only notifyexternal clients when triggered by default. However, it may be desiredthat this external notification be “muted” at some times withoutactually removing the event from the DAQ engine 30. Additionally, it maybe desired that the internal application within the softwarearchitecture 10 be notified when an event occurs. Thus, this inventionprovides such functionality. As previously discussed, externalnotification can be altered using the Set External Event On/Off commandwithin the DAQ API. Additionally, the software architecture 10preferably provides an internal function to turn internal notificationon and off. FIG. 28 shows examples of event notifications under thepossible configurations.

In this way, the invention has the ability to disable and re-enable therealization of the NVOEvents of FIG. 33 onto the internal communicationnetwork 14. In addition, the ability to disable and re-enable therealization of the NVOEvents of FIG. 33 as internal messages sent tosoftware component 16B within the same software operating environment16A of the software architecture 10.

FIG. 29 illustrates the functionality of an acknowledged event withinthis invention. In an acknowledged event, the software architecturewaits a pre-determined time for an acknowledgement message from theclient until processing the next event. If the pre-determined timeexpires, a pre-determined number of retries are executed. Preferably,all events are assumed to be unacknowledged by default. Thus, aftersending an event to the client(s), the DAQ engine 30 immediatelyprocesses the next event. However, some applications require that eventsbe acknowledged to insure that the message was received by the eventrequester. Using this technique, the sender can resend the event if theacknowledgment is not received. The acknowledgment confirms that therequester has received the event. The advantage to the preferredembodiment of providing the option for acknowledged events is that it isthe requester who determines the necessity of the acknowledgementaccording to the application requirements. Therefore, when the requestercreates the event using the mechanisms provided by the softwarearchitecture 10 within the interface to the DAQ 30, information isincluded in the message 28A which provides a further classification ofthe event as acknowledged or unacknowledged. As shown in the example inFIG. 29, upon occurrence of an acknowledged event the softwarearchitecture blocks all other event while waiting for an acknowledgmentfrom the client. If no acknowledgement is received, the softwarearchitecture 10 will re-send the event after a configurable amount oftime. This retry sequence will occur a configurable amount of times,until finally the software architecture stops attempting to send theevent and notifies the application through a callback function offailure.

FIG. 30 illustrates the security features provided within thisinvention. Because the execution of critical functions by external nodesis possible through the previously described protocols, this inventionprovides a firewall mechanism to restrict access to command execution.Commands that are deemed safety critical can be listed in a table,preferably in the file SAVariableMap.h, before compilation. Commands canbe listed specifically (with an API and Op Code) or as entire APIs (withan specific API and an Op Code=0xFF). The commands listed in this tableare claimed to be behind the firewall. As shown in FIG. 30, inventionprovides three levels of security access: Access Denied, Access Granted,and Temporary Access Granted.

Preferably, all nodes start with an access level of Access Denied bydefault. In this access level, the node is only allowed to execute thecommands in front of the firewall. Thus commands behind the firewall (orlisted in the firewall table) are not allowed to be executed. Uponsuccessful submission of a permanent password (within the payload of thePublish Node feedback message), a node is promoted to the Access Grantedsecurity level. In this access level, the node is allowed to execute allcommands, in front of and behind the firewall. For temporary accessbehind the firewall, a node can successfully submit a temporary accesspassword (within the payload of the Publish Node feedback message). Inthis access level, the node is given access to all commands, in front ofand behind the firewall, for a configurable amount of time. After thistime has expired, the node's access level is reverted to its previousstate.

Specifically, FIG. 30 contemplates two passwords each representing asecurity level recognized by the logic of the command firewall. Apassword will be transmitted by a component or client when the messageof the DAQ API, publish SA Node is broadcast. (see bytes 3 and 4 or OpCode 2). One of the passwords represents permanent access to all specialcommands that are considered to be behind the firewall. The secondpassword will grant temporary access to all special commands that areconsidered to be behind the firewall. Without a password, clients willhave access to all commands which are considered to be in front of thefirewall. The engineer responsible for the installation of the softwarearchitecture 10 onto a component 16 of the household appliance 12 willdetermine which commands are in front of and which commands are behindthe firewall of FIG. 30.

FIG. 31 illustrates an example of operation of the firewall securityprovided by this invention and shown in FIG. 30. By default, a node doesnot have access to commands behind the firewall. Thus, as shown, if anode without access attempts to execute a firewalled command, it will berejected. After an incorrect password submission, the firewalled commandwill still be rejected. Only after a successful password submission isthe node allowed to execute the firewalled command.

FIG. 32 illustrates the standard public interfaces which the softwarearchitecture 10 is able to implement. Shown is theApplicationSpecificAPI which is further populated with usefulfunctionality by the designer according to the needs of the application.Also shown is an example of associations with other software componentsof the software operating environment with which the softwarearchitecture 10 would interact.

FIG. 33 illustrates the preferred implementation of the softwarearchitecture 10. Shown are the internal functions and memory allocationsneeded to perform and support the functionality implied by FIG. 32. Alsoshown are helper classes (Command Handler, Dynamic Memory Heap, UpdateHandler, NVOEvent, TimeHandler, WIDECommHandler, MessageParser, andAppSpecificCommandHandler) which show the functional grouping of theinternal functions and memory allocations needed. Also shown are theassociations between the helper classes.

FIG. 34 shows the preferred organization of source code files of thesoftware architecture 10.

FIG. 35 shows a collection of inter-related state diagrams for threeprimary states (COMM_IDLE, COMM_EXPECTING ACK, and COMM_PENDING), witheach state possibly having a plurality of sub-states, and so on. Thefunctionality represented here is related to the collaborationassociations shown in FIG. 33. Its invocation is also referenced in FIG.11 as one of the standard interface functions invoked from the MAINexecution loop of the software operating system onto the softwarearchitecture 10.

The MAIN function of the software operating environment a6A (shown inFIG. 33 and in FIG. 11) invokes on SA_WideComm( ) shown in the SA classdefinition (where SA and its aggregate functionality is the SoftwareArchitecture 10). The result of the function invocation, is shown inFIG. 35. As shown in FIG. 11, MAIN invokes on SA_WideComm( )periodically within the software operating systems execution.

FIG. 35 shows a 2^(nd) indirect interaction with MAIN which is a resultof MAIN invoking on the WIDE function WIDE_EXEC( ). This collaborationis shown in FIG. 11 and in FIG. 35. In this case, WIDE softwareoperating layer 14A within the WIDE_EXEC( ) function invocation callsWIDE.BuildData( ) which in turn calls SA.WideCommHandler.SA_BuildData( )within 52. In FIG. 35, this invocation is shown within the COMM_PENDINGstate. This path of execution occurs when, in the previous state ofCOMM_IDLE, the logic within the sub-states of COMM_IDLE result in apending outbound message for the WIDE network 14. As shown in FIG. 33,this state transition is realized by the invocation of the functionWIDE.QueueMessage( ). This invocation, results in the invocation of thelogic contained within the COMM_PENDING state of FIG. 35.

The COMM_EXPECTING_ACK state of FIG. 35 is a result of an outbound eventhaving been initially created with a special indicator denotingacknowledgment required. If the event (also referred to as update) whichis being operated on within the COMM_PENDING state requiresacknowledgment, the state transition from COMM_PENDING will be toCOMM_EXPECTING_ACK. In this case, the event will be re-sent, byre-entering the COMM_PENDING state if a time out has expired withoutreceipt of the expected Acknowledgment message. This process will berepeated until either an Acknowledgement is received or until theconfigurable retry parameter (MAX_EVENT_RETRY which is incremented eachtime the event is re-transmitted) is exceeded.

FIG. 36 shows a collection of inter-related UML state diagrams. Shownare four primary states (READY, TRANSMIT SNAPSHOT, UPDATES_BLOCKED, andPROCESS_DAQ_EVENTS). The functionality represented here, is related tothe collaboration associations shown in FIG. 33. Its invocation is alsoreferenced in FIG. 11 as one of the standard interface functions invokedfrom the MAIN execution loop 11 of the software operating environmentonto the software architecture 10.

The purpose of the functionality represented by FIG. 36 is to evaluatethe structures (VOEvent) 31 of FIG. 33 determining if the conditions forevent transmission have occurred, collecting those, and setting theappropriate flags (Updates_Pending & Bounded Update) so that when theState Machines of 35 are executing, events conditions detected by theDAQ 30 are realized as WIDE Packets 24 onto the WIDE bus 14.

FIG. 37 shows two primary states (MSG_READY and MSG_PROCESS). Thefunctionality represented here is related to the collaborationassociations shown in FIG. 33 where WIDE callsSA.WideCommHandler.SA.AcceptData( ). Invocation into these statemachines are also referenced in FIG. 11 as functions invoked from theMAIN execution loop 11 of the software operating system onto thesoftware architecture 10 where MAIN calls SA.SA_ProcessIncomingEvents(). These inter-related state machines govern the execution of incomingcommands, responses to requests, and the handling of events.

FIG. 38 shows the execution of an ordered collection of messages of theclasses in FIG. 33 of the software operating environment. These messagesrepresent the execution path for a common set of logic referenced as‘Send WIDE Message’ in FIGS. 39, 40, 41, and 42. The invocation fromMAIN and WIDE (via WIDE_EXEC( )) are shown in FIG. 11.

FIG. 39 shows the execution of an ordered collection of messages of theclasses in FIG. 33 of the software operating environment. These messagesrepresent an interaction within a software operating environmentcontaining the software architecture 10. The invocation from MAIN isshown in FIG. 11. The diagram illustrates the messaging required to adda well formed NVOEvent memory structure to the DynamicMemoryHeap.

FIG. 40 shows an ordered collection of messages of the classes in FIG.33 of the software operating environment. These messages represent aninteraction within a software operating environment containing thesoftware architecture 10. The diagram illustrates the message executionof FIG. 37. And the invocation from MAIN is shown in FIG. 11. Thepurpose of the functionality represented by the diagram is to evaluatethe NVOEvent memory structures contained within the DynamicMemoryHeap,collect those and their appropriate data values whose event triggeringcriteria have been met, and to insure a realization of packets 24 ontothe internal communication network 14 for the purposes of notifyingother clients 16/22 of the NVOEvents which have met there triggercriteria and the associated data values.

FIGS. 41, 42, and 43 show an ordered collection of messages of theclasses in FIG. 33 of the software operating environment for the purposeof processing incoming commands (NVOs) from the Network 14. Thesemessages represent an interaction within a software operatingenvironment containing the software architecture 10. The invocationsfrom MAIN and WIDE (via WIDE_EXEC( )) are shown in FIG. 11. The figures,described individually in subsequent paragraphs, represent 3 cases ofalternate paths for execution.

FIG. 41 illustrates the messaging required to process incoming messagesfrom the internal communications network 14 from clients 22/16 which donot require a response [Command-NoReponse] containing meaningful dataother than a response transmitting the success or the reason for failureof the incoming message (the ACK or NAK of API ID=1, Op Code=1).

FIG. 42 illustrates the messaging required to process incoming messagesfrom the WIDE bus 14 from clients 22/16 which require a plurality ofresponse messages [Command-MultipleResponseRequired] containingmeaningful data in addition to a response which transmits the success orthe reason for failure of the incoming message (the ACK or NAK of APIID=1, Op Code=1).

FIG. 43 illustrates the messaging required to process incoming messagesfrom the internal communication network 14 from clients 22/16 whichrequire a single response messages[Command-SingleResponseRequired]containing meaningful data in addition to a response which transmits thesuccess or the reason for failure of the incoming message (the ACK orNAK of API ID=1, Op Code=1).

Taxonomy Control

A typical prior art approach to using a new controlling device tocontrol an appliance is to have the software component of the newcontrolling device duplicate the logic of the appliance controller sothat the new controlling device does not inadvertently request thesoftware component of the appliance controller to perform an operationof which it is incapable. This prior art approach further requirescommunications between the appliance and the new controlling deviceregarding the current state of the appliance. This prior art approach isinefficient since it requires duplication of logic on the newcontrolling device and the appliance controller. Furthermore, this priorart approach requires that new software must be written each timeappliance controller is introduced to the new controlling device.

The purpose of a control taxonomy is to avoid requiring this duplicationof software logic (often called business logic) between two interactingsoftware components in a controlling device and a controlled appliance.In particular this permits a command generator in a controlling deviceto readily control an appliance without any information about theappliance being controlled except the control taxonomy itself. This canenable the introduction of a “generic” controlling device to control newappliances, adapting control devices to newly available cycles orfunctionalities which have been added to an appliance, and switchingappliances between modes of operation where different operating cyclesor functionalities are available. It also makes control of applianceseasier for users since they need only be presented with choices whichare currently available from the appliance.

The present invention uses a structured taxonomy dataset to efficientlycommunicate to the controlling device just that information which thecontrolling device needs in order to generate a well formed command forthe appliance. As used herein, a well formed command is a command whichhas meaning and is performable by the appliance. The informationconveyed by the dataset includes a hierarchy of options and data inputsrequired to form the well formed command. In the preferred embodiment,it also includes semantic or contextual information to communicate inword or iconic form the available options so that a user can understandthe available choices and enter the appropriate data. This is preferablyaccomplished by labels within the dataset that are associated witharbitrary or non-user friendly identification elements. This allows thelogic of the software componentry which must interpret and process theTaxonomy to be decoupled from the presentation of the Taxonomy on a userinterface. (ex. Foreign language, Labels, Units).

Referring to the FIG. 44, generally, illustrating the improved controlstructure and method of the present invention, the appliance 12 beingcontrolled has a software component 216B having a appliance controllerand status generator. The controlling device 16, 22 used to control theappliance has a software component 116B with a command generator, aselection builder and a status interpreter. The controlling device 16,22 may be a programmable user interface such as a pda, web tablet, acell phone, an LCD attached to the appliance or a client device.

The taxonomy architecture, shown disposed in the appliance controller 16and logic, may alternatively be disposed in a remote location, such asin a controlling device or on the internet. The taxonomy architectureincludes a taxonomy generator, a taxonomy engine, a taxonomy translatorand a taxonomy structure. The taxonomy architecture generates a taxonomydataset defining taxonomy capabilities facilitating: the creation, bythe software component 1, of well formed commands that can betransformed by the taxonomy engine and optionally the taxonomytranslator into other well formed commands to be executed by softwarecomponent 2; the creation, by the software component 1, of the userinterface content; and the validation of status information beforepresenting to the user interface. Each of these components and theirinterrelationships are described in greater detail below.

Creation of the Taxonomy Dataset

The taxonomy dataset is derived from the operational capabilities of theappliance controller 16 structured in a manner to allow the commandgenerator in the software component 1 to interpret the dataset toaccomplish several results. More particularly, from time to time thetaxonomy engine uses the taxonomy structure and the state awareinformation to generate a taxonomy dataset reflective of the subset ofthe universe of options for commands that would be available from anappliance to those that are currently available from the appliance.

For example, the taxonomy dataset describes the available functionssupported by a software component 16B, each functions argument, and thevalid values of each argument in a data structure. In addition, taxonomydataset defines the valid values of feedback variables. Since this in adata structure, it can be transmitted and re-transmitted to clients 16or 22 as required. Changes to taxonomy dataset occur as the cycles ofoperation progress and the available commands or the valid values oftheir arguments change. Moreover, additional commands may becomeavailable or may become invalid as the cycle of operation progressesfrom Idle (see FIG. 7).

More particularly, the selection builder registers with the TaxonomyManager to receive notifications for new Taxonomy Engines. In response,the Taxonomy Manager passes references to all known Taxonomy Enginesback to the selection builder. The selection builder then requests fromeach Taxonomy Engine a Taxonomy Capabilities Data Set. The TaxonomyEngine evaluates a Taxonomy Structure comprised by the Controller Logicof Software Component 2 or alternatively a Document to generate aTaxonomy Capabilities Dataset. The selection builder then populates aset of psuedo command structures, which are a hierarchy of options,appropriate for an Application End Point (Examples of Application EndPoints are user interfaces for control or service or other intermediateapplication layers like an energy controller or home automation modelike vacation or goodnight.) and passes those structures to theApplication End Point allowing the Application End Point to beconfigured. Alternatively, the selection builder may directly configurethe application end point.

Communication and Use of the Dataset.

When a controlling device is networked with the appliance, the taxonomymanager establishes a relationship between the software component 1 andthe taxonomy architecture allowing the command generator to query forthe existence of taxonomy datasets, providing the software architecture1 access to a taxonomy dataset, and allowing the command generator andstatus interpreter to subscribe to taxonomy dataset updates. TheTaxonomy Translator is an optional component that translates theTaxonomy datasets between Software Components 1 and 2, if SoftwareComponents 1 and 2 are not designed to be interoperable with the sameembodiment of the Taxonomy dataset.

The taxonomy dataset is communicated to the controller of softwarecomponent 2 and to the selection builder of software component 1.Optionally, the taxonomy translator translates the taxonomy dataset to adifferent schematic definition of the command generator.

The command generator uses the taxonomy dataset to construct andpopulate a set commands structures available for selection by a userinterface or other client applications comprising a set of validcommands, their valid arguments, and each arguments valid values. Moreparticularly, the command generator uses the taxonomy dataset toconstruct one or more well formed commands which can then be transmittedto the controller. Since the taxonomy dataset can be reset and sent atdifferent times by the taxonomy engine, or the dataset can be updated byrevisions from the taxonomy engine, the Software Component 1 can have acurrent set of command structures then available for selection by a userinterface or other client application.

Thus, in essence, through use of the Taxonomy architecture, the softwarecomponent 2 or its proxy (the taxonomy engine) communicates to softwarecomponent 1 a rule set that can be interpreted by software component 1so that software component 1 does not request something of softwarecomponent 2 which software component 2 cannot accommodate and does notoperate on a state variable which is set to an invalid value.

Before the Application End Point is able to commence execution, it willrequest or register for status updates with a Status Interpreter. Thiswill allow the Application End Point to be populated with valid statevariables from the Status Generator before logic is executed and beforeuser interface componentry is rendered. The Status Interpreter willprocess Taxonomically correct status datasets and validate thosedatasets against the Taxonomy Capabilities Data Set. The StatusInterpreter request or register for status updates from the StatusGenerator of Software Component 2 via the Taxonomy Engine. Upon receiptof a Taxonomically correct status, the Status Interpreter will providenew status values to the Application end point.

The Application End Point executes resulting in a rendering of thecurrent status of software component 2 and a rendering of selectablepseudo command structures. Each time a selection is made from the pseudocommand structure, the selection builder populates a set of validsub-commands found in the Taxonomy Capabilities dataset appropriate forthe selection for further selection by the application end point. When acomplete selection is made, a structure containing all pseudo commandsare passed to the command generator.

The command generator will construct a Taxonomically correct well formedcommand and optionally via the Taxonomy Translator, invoke the commandonto the Controller of Software Component 2 via the Taxonomy Engine.

Execution

The well formed command is delivered to the controller of the applianceand executed by the appliance.

Typically, the command will result in a state change to the associatedmemory of Software Component 2 which will trigger a status updatecreated by the Status Generator and resulting in new renderings of stateto the Application end point. This change in state will result in a newCapabilities Taxonomy or a partial Capabilities Taxonomy which canreplace portions of the original Capabilities Taxonomy. The newCapabilities Taxonomy resulting in a different set of valid selectionsfor controlling the cycles of operation of Software Component 2.

Validation

The status interpreter uses the taxonomy dataset to validate statusupdates sent by the Taxonomy Engine or Translator from the StatusGenerator. In addition, the Taxonomy Structure, which is the source ofthe Taxonomy dataset, allows the controller to fully validate incomingcommands according the structure without additional logic outside of thedataset. For example, the Taxonomy Structure can be conceptually thoughtof as one or multiple decision trees, with each level of the taxonomyforming a different decision branch or set of decision branches, whereeach of the options and/or data inputs can form a different level. Thecycles of operation of an appliance require the user to select theoptions and/or data inputs in forming the well formed command. Theseselections can be compared against the decision tree to confirm thateach cycle, cycle attribute, or cycle option is found within theappropriate branch on the decision tree. If the expected cycle ofoperation, attribute and options are not found within the command, thenit is an indication that the command contains an error. The taxonomystructure thus serves to populate the user interface with availableoptions and data inputs for a given state of the appliance and alsoserve as the logic for validating the resulting command.

The taxonomy dataset is a data representation of the taxonomy structurewhich is an object or software structure. It contains all availablecommands, options and settings for an appliance at the current state andall valid status values at the current state. For example, the appliancecomprises multiple components interconnected by the internal network.Each of the components can have one or more devices. Each of the deviceshas one or more functionalities, which has one or more settings. All ofthe functionalities for all of the devices will not necessarily beavailable during each state of the appliance. As such, the taxonomydataset will comprise all options and data inputs for all devices thatare currently available.

FIGS. 45-48 illustrate one example of the Taxonomy control in thecontext of a user interface 16, 22 for a microwave that is populatedwith a taxonomy dataset indicating the available functions of theappliance 12 for the current state. The user can select from theparameters of the dataset to form the well formed command that will beissued to control the operation of the appliance 12.

FIG. 45 illustrates the available hierarchy of options and data inputs.The top level of the hierarchy begins with the cycle 100, which is shownto have the options of COOK, JET DEFROST, BAKED POTATO, STEAM COOK, AUTOREHEAT, AND DINNER PLATE, as illustrative examples. The user must selectone of the options from the top level.

Once the user selects an option from the top level, the next level ofthe hierarchy is exposed to the user based on the top level selection.In FIG. 46, the user has selected the COOK option and the user interfacethen displays data inputs, in the form of TIME 102 and POWER LEVEL 104,available for that option and necessary to form the well formed command.

FIG. 47 illustrates the situation were the selection of a top leveloption exposes options at a sub-level. In FIG. 47, the JET DEFROST isselected, which exposes the sub-level of types of meat 106. The usermust select the appropriate meat option in completing the well formedcommand. Data inputs in the form of weight 108 and defrost level 110 areexposed and must be selected to complete the well formed command.

Once the user has selected the options and data inputs from the taxonomydataset accessed by the user interface, the command generator will formthe well formed command and send it to Software Component 2 on componentof the appliance for implementation. This is done only after the wellformed command has passed through the validation process. The controllerand logic of Software Component 2 then uses the well formed command tocontrol the operation of the devices to effect the well formed command.

A detailed example of the creation of the taxonomy dataset and the wellformed command should prove useful. The creation of the taxonomy datasetfor the microwave of FIG. 45 that discloses multiple cooking cycles wasconstructed by the selection builder from the taxonomy capabilitiesdataset as is illustrated in XML as follows: <device id=″microwave″label=″Microwave Oven″> <device id=″ovenCavity″ label=″Microwave Oven″><char name=″cycle″ label=″Cycle″ default=″timedCook″> <settingname=″timedCook″ label=″COOK″ /> <char name=″turntable″label=″Turntable″ default=″on″> <setting name=″on″ label=″ON″ /><setting name=″off″ label=″OFF″ /> </char> <range name=″duration″label=″Duration″ default=″30″ units=″seconds″ max=″6039″ min=″60″inc=″1″ /> <range name=″power″ label=″Power Level″ default=″100″units=″%″ max=″100″ min=″50″ inc=″10″ /> </setting> <settingname=”jetdefrost” label=”Jet Defrost”/> <char name =foodType label=”Food Type”/> <setting name=″poultry″ label=″POULTRY″ /> <settingname=″meat″ label=″MEAT″ /> <setting name=″fish″ label=″FISH″ /> </char></setting>  |  |  |  etc </char> </device> </device>

If the user of the microwave of FIG. 45 chooses to Cook for 30 secondsat 90% power with the Turntable On, a well formed command of theTaxonomic schema would be transmitted optionally to the TaxonomyTranslator and to the Taxonomy. The command of the form:  <command id=“microwave ”> <device id=“ovenCavity”> <sequence> <step id=“21”> <charname=“cycle” setting=“bake”/> <char name=“power” setting=“90”/> <charname=“duration” setting=“30”/> <char name=“turntable” setting=“on”/></step> </sequence> </device> </command>

The Taxonomy Engine would then traverse the Taxonomy Structure totransform the well formed command of the Taxonomic schema to a wellformed command of the Controller of Software Component 2 of the packetstructure 28. The Taxonomy Structure is a superset of the TaxonomyCapabilities Dataset. For each specifiable command element above (ie.Cycle, Power, Duration, and Turntable) an additional collection of keywords and values necessary to form Payload 28A would be associatedwithin the Taxonomy Structure. These key words would include API Id, OpCode, and Position Index into the Payload 28A where Position Index couldbe a byte offset or a bit offset.

The Taxonomy Dataset could be constructed to directly represent theuniverse of possible commands of the APIs of software architecture 10providing useful functionality for a service, factory, or laboratoryengineer or technician.

While the invention has been specifically described in connection withcertain specific embodiments thereof, it is to be understood that thisis by way of illustration and not of limitation, and the scope of theappended claims should be construed as broadly as the prior art willpermit.

1. A method of identifying nodes in a network having a plurality ofnodes, each of the nodes having at least one identifier frompre-determined group of identifiers, with each identifier identifying atleast one functionality applicable such node, the method comprising: atleast one node sending over the network a message configured to ask forthe presence of at least one identifier from the pre-determined group ofidentifiers, and at least one other node sending a feedback messageaffirming the existence of the at least one identifier on the at leastone other node.
 2. The method of claim 1 wherein a node will ignore amessage asking for the presence of an inapplicable identifier.
 3. Themethod of claim 2 wherein the node ignores the message by failing tosend a feedback message in response to the message.
 4. The method ofclaim 1 wherein a message may be broadcast to one, some, or all of thenodes.
 5. The method of claim 4 wherein a message is to a specific node.6. The method of claim 4 wherein a node ignores messages asking for aninapplicable identifier if the message is broadcast to more than onenode.
 7. The method of claim 1 wherein the message is a discovery querythat requests information and the feedback message is a network messagecontaining the requested information of the discovery query.
 8. Themethod of claim 7 wherein the feedback message is sent to one, some orall of the nodes.
 9. The method of claim 8 wherein the feedback messageis directed to the node that sent the discovery query.
 10. The method ofclaim 1 wherein the feedback message relates to at least one ofevaluating network integrity, enabling dynamic network behavior, andconfiguring the interactions between nodes.
 11. The method of claim 1wherein each identifier represents a group of common functionality. 12.The method of claim 11 wherein the message may request informationrelated to at least one of the functionality of an identifier andinformation about the identifier.
 13. The method of claim 12 wherein theidentifier is implemented by a software module residing on the node andthe message requests information regarding the functionality of thesoftware module and the identity of the software module.
 14. The methodof claim 1 wherein the sending of the message is initiated by a new nodebroadcasting a node alive message.
 15. The method of claim 1 wherein anode may send a message asking any other node for at least one of: one,some, or all of the functional identifiers supported and uniqueidentifier information.
 16. The method of claim 1 wherein the feedbackmessage includes the number of instances of the existence of therequested identifiers.
 17. The method of claim 16 wherein the nodesending the message may send a follow-up message in response to thefeedback message asking for additional identification information touniquely identify the duplicate instances of an identifier at a node.18. A method of identifying nodes in an appliance having a plurality ofinterconnected nodes forming a communications network, at least some ofthe nodes having a corresponding component, wherein the components areoperably coupled by the communications network to cooperatively performa useful cycle of operation, each of the nodes having at least oneidentifier from pre-determined group of identifiers, with eachidentifier identifying at least one functionality applicable to thecorresponding component, the method comprising: at least one nodesending over the network a command configured to ask for the presence ofat least one identifier from the pre-determined group of identifiers,and at least one other node sending a feedback message affirming theexistence of the at least one identifier on the at least one other node.19. The method of claim 18 wherein a message may be broadcast to one,some, or all of the nodes.
 20. The method of claim 18 wherein thecommand is a discovery query that requests information and the feedbackmessage is a network message containing the requested information of thediscovery query.
 21. The method of claim 18 wherein the feedback messagerelates to at least one of evaluating network integrity, enablingdynamic network behavior, and configuring the interactions betweennodes.
 22. The method of claim 18 wherein the identifier is implementedby a software module residing on the component and the command requestsinformation regarding the functionality of the component from thesoftware module and the identity of the software module.
 23. The methodof claim 18 wherein the sending of the command is initiated by a newnode broadcasting a node alive message.
 24. The method of claim 18wherein a node may send a command asking any other node for at least oneof: one, some, or all of the functional identifiers supported and uniqueidentifier information.
 25. The method of claim 18 wherein the feedbackmessage includes the number of instances of the existence of therequested identifiers.
 26. The method of claim 18 wherein the nodesending the command may send a follow-up command in response to thefeedback message asking for additional identification information touniquely identify the duplicate instances of an identifier at a node.